하다보면 늘겠지

220808-220814

마닐라 — Sun, 14 Aug 2022 23:59:05 +0900

0808(월)

백준 문제 풀기

오브젝트(~70p)

0809(화)

백준 문제 풀기

오브젝트(~106p)

Collection 포스팅

0810(수)

프로그래머스 모의고사 풀기

스프링 인 액션(~47p)

다음주면 퇴사한 지 거의 1년이 다 되가는 시점에 최종합격 연락을 받게 됐다!

이것저것 많은 경험을 해볼 수 있을 곳인것 같아서 기대가 된다.

이번주는 읽고 싶었던 책들 읽으면서 좀 쉬었고 다음주 수요일부터 첫 출근인데 이제 TIL 보다는 업무에서 겪었던 문제나 기술같은 것들을 정리하는 식으로 블로그를 운영해보면 어떨까싶어서 그런식으로 해보려 한다!

좀 적응하면 다시 서적 읽으면서 자기개발하자!

자바의 Collection Framework - 동기화, 병렬 처리

마닐라 — Tue, 9 Aug 2022 16:48:50 +0900

자바의 컬렉션 프레임워크의 대부분의 클래스들은 싱글 스레드 환경에서 사용될 수 있도록 설계 되었습니다.

그렇기 때문에 여러 스레드가 동시에 컬렉션에 접근한다면 의도하지 않게 요소가 변경될 수 있습니다.

Synchronized Collection

Vector와 Hashtable은 동기화된(synchronized) 메서드로 구성되어 있기 때문에 멀티 스레드 환경에서 안전하게 요소를 처리할 수 있지만 ArrayList, HashSet, HashMap은 동기화된 메서드로 구성되어 있지 않아 멀티 스레드 환경에서 안전하지 않습니다.

경우에 따라서는 ArrayList, HashSet, HashMap을 싱글 스레드 환경에서 사용하다가 멀티 스레드 환경으로 전달할 필요도 있을 것입니다.

이런 경우를 대비해서 컬렉션 프레임워크는 비동기화된 메서드를 동기화된 메서드로 래핑하는 Collections의 synchronizedXXX() 메서드를 제공하고 있습니다.

파라미터로 비동기화된 컬렉션을 대입하면 동기화된 컬렉션을 리턴합니다.

Concurrent Collection

동기화된 컬렉션은 멀티 스레드 환경에서 하나의 스레드가 요소를 안전하게 처리하도록 도와주지만, 전체 요소를 빠르게 처리하지는 못합니다.

하나의 스레드가 요소를 처리할 때 전체 잠금이 발생하여 다른 스레드는 대기 상태(blocked)가 되기 때문입니다.

그렇기 때문에 멀티 스레드가 병렬적으로 컬렉션의 요소들을 처리할 수 없습니다.

자바는 멀티 스레드가 컬렉션의 요소를 병렬적으로 처리할 수 있도록 특별한 컬렉션을 제공합니다.

java.util.concurrent 패키지에서 제공하고 있으며 제공하는 클래스의 일부를 어떤 방식으로 처리를 하는지에 대해서 알아보겠습니다.

CopyOnWriteArrayList

동기화된 ArrayList를 생성하는 방법은 두 가지가 있습니다.

1. Collections.synchronizedList()

2. CopyOnWriteArrayList

1번의 경우에는 JDK 1.2 버전에 추가 되었는데, 반환되는 컬렉션은 모든 읽기와 쓰기 동작에 대해 동기화가 되어 있습니다.

따라서 상당히 비효율적이고 이러한 점을 보완한 CopyOnWriteArrayList가 등장하게 됩니다.

읽기 동작

CopyOnWriteArrayList는 모든 쓰기 동작에 원본 배열에 있는 요소를 복사하여 임시 배열을 만들고, 이 임시 배열에 쓰기 동작을 수행한 후 원본 배열을 갱신합니다.

이 덕분에 읽기 동작은 잠금이 걸리지 않아 1번의 방법보다 성능이 더 좋습니다.

쓰기 동작

CopyOnWriteArrayList는 쓰기 동작의 경우에는 1번의 방법과 같이 잠금을 수행합니다.

이 때 CopyOnWriteArrayList는 임시 배열을 만드는 과정이 있으므로 1번의 방법보다 성능이 떨어집니다.

따라서 해당 컬렉션은 읽기 동작이 빈번한 경우에 사용하는 것이 효율적으로 볼 수 있습니다.

CopyOnWriteArraySet의 경우에도 자료구조의 특징만 제외하면 동일합니다.

ConcurrentHashMap

동기화된 HashMap을 생성하는 방법은 두 가지가 있습니다.

1. Collections.synchronizedMap()

2. ConcurrentHashMap

1번의 경우에도 synchronizedList()와 같이 모든 읽기와 쓰기 동작에 대해 동기화가 되어 있습니다.

ConcurrentHashMap은 각 테이블을 버킷을 독립적으로 잠그는 방식을 사용합니다.

빈 버킷에 요소를 삽입할 경우에는 잠금 대신 CAS 알고리즘을 사용하고, 그 외의 변경은 각 버킷의 첫 번째 노드를 기준으로 부분적인 잠금을 획득하여 동시성을 보장합니다.

CAS이란 Compare And Swap의 약자로 현재 쓰레드에 저장된 값과 메인 메모리에 저장된 값을 비교하여 같다면 새로운 값으로 교체하고(true), 다르다면 재시도를 수행하는(false) 알고리즘입니다.

성공할 때 까지 무한 루프를 돌긴 하지만 멀티 스레드 환경에서 스레드들의 상태가 반복적으로 blocked<->running 되는 것보다는 성능 면에서 좋습니다.

자바에서는 volatile이라는 키워드로 메인 메모리에 접근할 수 있습니다.

CAS를 통해 synchronized가 blocking하는 단점을 해결하여 non-blocking 방식으로 동시성을 보장할 수 있습니다.

참고로 synchronized 블록의 경우에는 synchronized 블록 진입전 후에 메인 메모리와 CPU 캐시 메모리의 값을 동기화하는 방식으로 원자성을 보장합니다.

출처

https://github.com/castello/javajungsuk_basic/blob/master/javajungsuk_basic_%EC%9A%94%EC%95%BD%EC%A7%91.pdf

https://palpit.tistory.com/entry/Java-%EC%BB%AC%EB%A0%89%EC%85%98-%ED%94%84%EB%A0%88%EC%9E%84%EC%9B%8C%ED%81%AC-%EB%8F%99%EA%B8%B0%ED%99%94-%EB%B3%91%EB%A0%AC-%EC%B2%98%EB%A6%AC

https://steady-coding.tistory.com/568

https://steady-coding.tistory.com/575

https://javaplant.tistory.com/23

220801-220807

마닐라 — Sun, 7 Aug 2022 23:59:39 +0900

0801(월)

면접 보기 + 수요일 면접 준비

0802(화)

백준 문제 풀기

면접 준비

0803(수)

NHN 코딩테스트 + 기술 면접 보기

백준 문제 풀기

면접 질문 정리

0804-0805(목,금)

코테 준비

0806(토)

현대오토에버, 토스 코딩테스트 보기

지원서 작성

수요일에 NHN 면접은 후기대로 진행된 면접이었다.

코딩테스트는 없었고 과제테스트였는데 얼굴이랑 화면을 동시에 찍어야하고 인터넷 검색이 안돼서 조금은 부담스러웠지만 그래도 나쁘지 않게 구현한 것 같다.

pre-test는 그다지 어려운 부분들은 없었지만 답변을 못한 부분이 좀 있었다.

시험이나 테스트에 대해서 좀 더 나은 답을 찾아가는 식으로 진행했는데 좋은 경험이었다.

토요일에는 오전에 현대오토에버, 토스 코딩테스트를 봤는데, 현대오토에버는 IDE, 검색이 불가능이라 그런지 난이도가 크게 어렵진 않았던 것 같다.

토스는 코딩테스트 1시간 30분, 서술형 30분이었고 각 7문제, 5문제였다.

정신 없이 풀어서 문제는 잘 기억나지 않는데 난이도는 낮은 편이었다.

근데 시간이 너무 촉박해서 예외 케이스를 못 잡은 문제가 몇 개 있었다.

올솔한 사람도 있다는 걸 보고 더 열심히 해야겠다고 느꼈다.

서술형 문제는 실무 경험 능력이 뛰어난 사람을 뽑겠다는 의지가 보였다.. 제대로 답변한 게 얼마 없는듯하다.

다음주도 코테있으니까 코테 준비하면서 포스팅도 다시 하자~!

220725-220731

마닐라 — Sun, 31 Jul 2022 23:59:06 +0900

0725

운영체제 강의 보기

백준 문제 풀기

0726

운영체제 강의 보기

백준 문제 풀기

0727

백준 문제 풀기

면접 준비

0728

백준 문제 풀기

프로그래머스 모의고사 보기(1.해시 2.투포인터 3.자료구조 4.DFS+구현)

면접 준비

0730

백준 문제 풀기

프로그래머스 모의고사 보기(1.DFS 2.해쉬+투포인터 3.BFS)

면접 준비

0731

면접 준비

다음주 코테보기 전에 프로그래머스 모의고사를 봤는데 모의고사긴 하지만 2번 모두 올솔해서 기분좋았다.

하다보면 늘긴하는 것 같다!

다음주에 면접, 코테 두 번씩 잡혀있는데 잘 보자!!

빙산

마닐라 — Wed, 27 Jul 2022 18:31:48 +0900

문제 설명

https://www.acmicpc.net/problem/2573

2573번: 빙산

첫 줄에는 이차원 배열의 행의 개수와 열의 개수를 나타내는 두 정수 N과 M이 한 개의 빈칸을 사이에 두고 주어진다. N과 M은 3 이상 300 이하이다. 그 다음 N개의 줄에는 각 줄마다 배열의 각 행을

www.acmicpc.net

접근

bfs 문제였는데 큐가 2가지 필요했다.

1. 빙산을 한번에 녹이기 위한 큐

2. 두 덩어리 이상으로 분리되어있는지 확인하기 위한 큐

‍ 코드

import java.io.*;
import java.util.*;

public class Main {
    static int[] arr, dx = {-1, 1, 0, 0}, dy = {0, 0, -1, 1};
    static int[][] board;
    static boolean[][] visited;
    static int n, m, k, t, num, cnt, second;
    static ArrayList<Integer> list = new ArrayList<>();
    static Queue<Point> q = new LinkedList<>();

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        StringTokenizer st = new StringTokenizer(br.readLine());
        n = Integer.parseInt(st.nextToken());
        m = Integer.parseInt(st.nextToken());

        board = new int[n][m];
        visited = new boolean[n][m];
        for (int i = 0; i < n; i++) {
            st = new StringTokenizer(br.readLine());
            for (int j = 0; j < m; j++) {
                board[i][j] = Integer.parseInt(st.nextToken());
                if(board[i][j] != 0) q.add(new Point(i, j, board[i][j]));
            }
        }

        System.out.println(bfs());
    }

    private static int bfs() {
        while (!q.isEmpty()) {
            int len = q.size();
            for(int i = 0; i < len; i++) {
                Point cp = q.poll();

                int cnt = 0;
                //상하좌우 확인해서 바닷물 몇 개인지 확인
                for(int j = 0; j < 4; j++) {
                    int nx = cp.x + dx[j];
                    int ny = cp.y + dy[j];
                    if(nx<0 || ny<0 || nx>=n || ny>=m) continue;
                    if(board[nx][ny] == 0) cnt++;
                }
                //일단 바닷물 갯수만큼 빼서 큐에 다시 넣어놓기
                q.offer(new Point(cp.x, cp.y, board[cp.x][cp.y]-cnt));
            }

            //모든 좌표 다 확인했으면 원배열을 갱신시켜주기
            for(int i = 0; i < len; i++) {
                Point cp = q.poll();
                board[cp.x][cp.y] = cp.cnt < 0 ? 0 : cp.cnt;
                //빙산이 남아있을 때만 큐에 다시 넣어주기
                if(cp.cnt > 0) q.offer(new Point(cp.x, cp.y, board[cp.x][cp.y]));
            }
            second++;
            //두 덩어리 이상으로 분리되는지 확인
            if(isMany()) return second;
        }
        return 0;
    }

    private static boolean isMany() {
        visited = new boolean[n][m];
        cnt = 0;
        for(int i = 0; i < n; i++) {
            for(int j = 0; j < m; j++) {
                //인접한 빙산 모두 방문처리
                if(board[i][j] > 0 && !visited[i][j]) {
                    bfs2(i, j);
                    cnt++;
                }
            }
            if(cnt >= 2) return true;
        }
        return false;
    }

    private static void bfs2(int x, int y) {
        Queue<Point> mq = new LinkedList<>();
        mq.offer(new Point(x, y));
        while(!mq.isEmpty()) {
            Point cp = mq.poll();
            for(int i = 0; i < 4; i++) {
                int nx = cp.x + dx[i];
                int ny = cp.y + dy[i];

                if(nx<0 || ny<0 || nx>=n || ny>=m || visited[nx][ny] || board[nx][ny] == 0) continue;
                visited[nx][ny] = true;
                mq.offer(new Point(nx, ny));
            }
        }
    }

    private static class Point {
        private int x;
        private int y;
        private int cnt;

        public Point(int x, int y) {
            this.x = x;
            this.y = y;
        }

        public Point(int x, int y, int cnt) {
            this.x = x;
            this.y = y;
            this.cnt = cnt;
        }

        @Override
        public String toString() {
            return "Point{" +
                    "x=" + x +
                    ", y=" + y +
                    ", cnt=" + cnt +
                    '}';
        }
    }
}

직사각형 탈출

마닐라 — Wed, 27 Jul 2022 17:24:33 +0900

문제 설명

https://www.acmicpc.net/status?user_id=chqdlstjd2&problem_id=16973&from_mine=1

채점 현황

www.acmicpc.net

접근

전형적인 BFS 문제

다른 부분은 좌표 하나만 확인하는 것이 아닌 직사각형으로 확인해야 했던 문제

직사각형의 첫 시작 좌표들로 방문여부를 체크

‍ 코드

import java.io.*;
import java.util.*;

public class Main {
    static int[] arr, dx = {-1,1,0,0}, dy = {0,0,-1,1};
    static int[][] board;
    static boolean[][] visited;
    static int n, m, k, t, num, cnt, second;
    static ArrayList<Integer> list = new ArrayList<>();

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        StringTokenizer st = new StringTokenizer(br.readLine());
        n = Integer.parseInt(st.nextToken());
        m = Integer.parseInt(st.nextToken());

        board = new int[n+1][m+1];
        visited = new boolean[n+1][m+1];
        for(int i = 1; i <= n; i++) {
            st = new StringTokenizer(br.readLine());
            for(int j = 1; j <= m; j++) {
                board[i][j] = Integer.parseInt(st.nextToken());
            }
        }

        st = new StringTokenizer(br.readLine());
        int h = Integer.parseInt(st.nextToken());
        int w = Integer.parseInt(st.nextToken());
        int sx = Integer.parseInt(st.nextToken());
        int sy = Integer.parseInt(st.nextToken());
        int fx = Integer.parseInt(st.nextToken());
        int fy = Integer.parseInt(st.nextToken());

        //시작 좌표를 이용해서 좌표 방문여부 판단
        Queue<Point> q = new LinkedList<>();
        q.add(new Point(sx, sy, 0));
        visited[sx][sy] = true;

        boolean flag = false;
        out:while (!q.isEmpty()) {
            int len = q.size();
            for(int k = 0; k < len; k++) {
                Point cp = q.poll();
                if(cp.x == fx && cp.y == fy) {
                    flag = true;
                    System.out.println(cp.cnt);
                    break out;
                }
                for(int i = 0; i < 4; i++) {
                    int nx = cp.x + dx[i];
                    int ny = cp.y + dy[i];
                    if(nx<1 || ny<1 || nx>n || ny>m || visited[nx][ny]) continue;
                    //직사각형을 놓을 수 있는 위치인지 확인
                    if(nx+h > n+1 || ny+w > m+1) continue;
                    //그 위치들 중 벽이 없는지도 확인
                    if(isArrangeRectangle(nx, ny, h, w)) {
                        visited[nx][ny] = true;
                        q.offer(new Point(nx, ny, cp.cnt+1));
                    }
                }
            }
        }

        if(!flag) System.out.println(-1);

    }

    private static boolean isArrangeRectangle(int nx, int ny, int h, int w) {
        for(int i = nx; i < nx+h; i++) {
            for(int j = ny; j < ny+w; j++) {
                if(board[i][j] != 0) return false;
            }
        }
        return true;
    }

    private static class Point {
        private int x;
        private int y;
        private int cnt;

        public Point(int x, int y, int cnt) {
            this.x = x;
            this.y = y;
            this.cnt = cnt;
        }

        @Override
        public String toString() {
            return "Point{" +
                    "x=" + x +
                    ", y=" + y +
                    ", cnt=" + cnt +
                    '}';
        }
    }
}

움직이는 미로 탈출

마닐라 — Wed, 27 Jul 2022 16:30:13 +0900

문제 설명

https://www.acmicpc.net/problem/16954

16954번: 움직이는 미로 탈출

욱제는 학교 숙제로 크기가 8×8인 체스판에서 탈출하는 게임을 만들었다. 체스판의 모든 칸은 빈 칸 또는 벽 중 하나이다. 욱제의 캐릭터는 가장 왼쪽 아랫 칸에 있고, 이 캐릭터는 가장 오른쪽

www.acmicpc.net

접근

q사이즈만큼 루프를 돌린다음 벽을 내려한다!

해당 조건이 없으면 한 칸을 이동할 때 마다 벽이 내려가게 됨

방문조건을 고려하려면 q사이즈 루프돌때마다 새로 방문 배열을 만들어줘야 했는데 딱히 고려안해도 메모리, 시간초과가 나지는 않았다.

‍ 코드

import java.io.*;
import java.util.*;

public class Main {
    static int[] arr, dx = {-1,1,0,0,-1,-1,1,1,0}, dy = {0,0,-1,1,-1,1,-1,1,0};
    static char[][] board;
    static boolean[][] visited;
    static int n, m, k, t, num, cnt, second;
    static ArrayList<Integer> list = new ArrayList<>();

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        //StringTokenizer st = new StringTokenizer(br.readLine());
        //n = Integer.parseInt(st.nextToken());
        //m = Integer.parseInt(st.nextToken());
        board = new char[8][8];
        visited = new boolean[8][8];
        for(int i = 0; i < 8; i++) {
            String s = br.readLine();
            for(int j = 0; j < 8; j++) {
                board[i][j] = s.charAt(j);
            }
        }

        if(bfs()) System.out.println(1);
        else System.out.println(0);

    }

    private static boolean bfs() {
        Queue<Point> q = new LinkedList<>();

        q.add(new Point(7, 0));

        while (!q.isEmpty()) {
            int len = q.size();
            for(int k = 0; k < len; k++) {
                Point cp = q.poll();
                if (cp.x == 0 && cp.y == 7) return true;
                //현 위치가 벽이면 더이상 못감
                if (board[cp.x][cp.y] == '#') continue;

                //욱제 이동
                for (int i = 0; i < 9; i++) {
                    int nx = cp.x + dx[i];
                    int ny = cp.y + dy[i];

                    if (nx<0 || ny<0 || nx>=8 || ny>=8 || board[nx][ny]=='#') continue;
                    q.offer(new Point(nx, ny));
                }
            }
            //벽 아래로 내리기
            for (int i = 7; i >= 0; i--) {
                for (int j = 0; j < 8; j++) {
                    //벽 아래로 내리기 -> 내린 벽의 위치 = 욱제 위치 이면 더 이상 이동 불가
                    if (board[i][j] == '#') {
                        board[i][j] = '.';
                        if (i == 7) continue;
                        board[i + 1][j] = '#';
                    }
                }
            }
            cnt++;
        }
        return false;
    }


    private static class Point {
        private int x;
        private int y;

        public Point(int x, int y) {
            this.x = x;
            this.y = y;
        }

        @Override
        public String toString() {
            return "Point{" +
                    "x=" + x +
                    ", y=" + y +
                    '}';
        }
    }
}

말이 되고픈 원숭이

마닐라 — Wed, 27 Jul 2022 11:06:36 +0900

문제 설명

https://www.acmicpc.net/problem/1600

1600번: 말이 되고픈 원숭이

첫째 줄에 정수 K가 주어진다. 둘째 줄에 격자판의 가로길이 W, 세로길이 H가 주어진다. 그 다음 H줄에 걸쳐 W개의 숫자가 주어지는데, 0은 아무것도 없는 평지, 1은 장애물을 뜻한다. 장애물이 있

www.acmicpc.net

접근

k = 1일 때 처음부터 움직일 수도 있지만 인접한 방향으로만 이동하다가 중간에 말처럼 이동할 수도 있기 때문에 그 부분 때문에 3차원 배열을 사용했음

며칠전 문제에서 해당하는 위치를 바로 리턴안해줬더니 시간초과가 뜨는 문제가 있어서 이번엔 지점 찾으면 바로 리턴해주는 식으로 접근했는데, 이번 문제에서는 100%에서 틀렸습니다.가 떴다.

이 문제에서는 2갈래로 이동이 가능하다보니 각자에서 나오는 좌표가 최적이 아닌 케이스가 하나 존재하는듯하다.

‍ 코드

import java.io.*;
import java.util.*;

public class Main {
    static int[] dx = {-1,1,0,0};
    static int[] dy = {0,0,-1,1};
    static int[] hx = {-2,-2,-1,-1,1,1,2,2};
    static int[] hy = {-1,1,-2,2,-2,2,-1,1};
    static int[] arr;
    static int[][] board;
    static boolean[][][] visited;
    static int n, m, k, t, num, cnt, second;
    static ArrayList<Integer> list = new ArrayList<>();

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        k = Integer.parseInt(br.readLine());
        StringTokenizer st = new StringTokenizer(br.readLine());
        n = Integer.parseInt(st.nextToken());
        m = Integer.parseInt(st.nextToken());
        board = new int[m][n];
        visited = new boolean[m][n][k+1];
        for(int i = 0; i < m; i++) {
            st = new StringTokenizer(br.readLine());
            for(int j = 0; j < n; j++) {
                board[i][j] = Integer.parseInt(st.nextToken());
            }
        }

        if(bfs(0,0)) System.out.println(second);
        else System.out.println(-1);

    }

    private static boolean bfs(int x, int y) {
        Queue<Point> q = new LinkedList<>();
        //second 이동 횟수, cnt 말처럼 움직인 횟수
        q.add(new Point(x, y, 0, k));
        visited[x][y][k] = true;

        while (!q.isEmpty()) {
            Point cp = q.poll();
            if(cp.x == m-1 && cp.y == n-1) {
                second = cp.second;
                return true;
            }
            int nx, ny;
            for(int i = 0; i < 4; i++) {
                nx = cp.x + dx[i];
                ny = cp.y + dy[i];
                if(nx<0 || ny<0 || nx>=m || ny>=n || visited[nx][ny][cp.cnt] || board[nx][ny]==1) continue;
                visited[nx][ny][cp.cnt] = true;
                q.offer(new Point(nx, ny, cp.second+1, cp.cnt));
            }

            if(cp.cnt > 0) {
                for(int i = 0; i < 8; i++) {
                    nx = cp.x + hx[i];
                    ny = cp.y + hy[i];
                    if(nx<0 || ny<0 || nx>=m || ny>=n || visited[nx][ny][cp.cnt-1] || board[nx][ny]==1) continue;
                    visited[nx][ny][cp.cnt-1] = true;
                    q.offer(new Point(nx, ny,cp.second+1, cp.cnt-1));
                }
            }
        }
        return false;
    }


    private static class Point {
        private int x;
        private int y;
        private int second;
        private int cnt;

        public Point(int x, int y, int second, int cnt) {
            this.x = x;
            this.y = y;
            this.second = second;
            this.cnt = cnt;
        }

        @Override
        public String toString() {
            return "Point{" +
                    "x=" + x +
                    ", y=" + y +
                    ", second=" + second +
                    '}';
        }
    }
}

숫자고르기

마닐라 — Tue, 26 Jul 2022 22:46:26 +0900

문제 설명

https://www.acmicpc.net/problem/2668

2668번: 숫자고르기

세로 두 줄, 가로로 N개의 칸으로 이루어진 표가 있다. 첫째 줄의 각 칸에는 정수 1, 2, …, N이 차례대로 들어 있고 둘째 줄의 각 칸에는 1이상 N이하인 정수가 들어 있다. 첫째 줄에서 숫자를 적절

www.acmicpc.net

접근

범위가 그렇게 크지 않아서 조합으로 풀 수 있겠다 싶었는데, 시간초과가 났다.

1번 ~ n번까지 각 숫자에 대해서 배열에 해당하는 값(인덱스)을 찾아야한다.

idx번의 값과 배열의 idx 인덱스와의 값이 매칭되면 리스트에 넣어주면 된다.

‍ 코드

import java.io.*;
import java.util.*;

public class Main {
    static int[] arr;
    static boolean[] visited;
    static int n, m, k, t, num;
    static ArrayList<Integer> list = new ArrayList<>();

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        StringTokenizer st = new StringTokenizer(br.readLine());
        n = Integer.parseInt(st.nextToken());
        arr = new int[n+1];
        visited = new boolean[n+1];
        for(int i = 1; i <= n; i++) {
            arr[i] = Integer.parseInt(br.readLine());
        }

        //1~n까지 탐색
        //arr 어느 인덱스에 있는지 확인
        for(int i = 1; i <= n; i++) {
            visited[i] = true;
            num = i;
            dfs(i);
            visited[i] = false;
        }
        
        System.out.println(list.size());
        for (Integer number : list) {
            System.out.println(number);
        }
    }

    private static void dfs(int idx) {
        if(arr[idx] == num) {
            //System.out.println(num + "은 arr의 " + idx +"번째 인덱스에 있다.");
            list.add(num);
        }

        if(!visited[arr[idx]]) {
            visited[arr[idx]] = true;
            dfs(arr[idx]);
            visited[arr[idx]] = false;
        }
    }
}

샘터

마닐라 — Tue, 26 Jul 2022 20:56:05 +0900

문제 설명

https://www.acmicpc.net/problem/18513

18513번: 샘터

첫째 줄에 자연수 N과 K가 공백을 기준으로 구분되어 주어진다. (1 ≤ N, K ≤ 100,000) 둘째 줄에 N개의 샘터의 위치가 공백을 기준으로 구분되어 정수 형태로 주어진다. (-100,000,000 ≤ 샘터의 위치 ≤

www.acmicpc.net

접근

배열이 아닌 Set을 이용해서 좌표 방문 여부를 체크해줬는데 계속 메모리 초과가 났었다.

위의 문제는 집을 모두 지었을 때의 체크를 루프 바깥에서 해줬기 때문이다.

그리고 바깥에서 체크를 해주면 루프 안에서 집이 하나 더 만들어질 수도 있기 때문에 오답이다.

타 블로그를 참고해서 새롭게 알게된 문법이 있다.

out:while 문법을 쓰고 안에서 break out;을 사용하면 while 문을 바로 빠져나온다.

그리고나서도 계속 틀렸습니다.가 떴는데, 샘터의 위치는 -1억~1억이지만 집의 좌표는 정해져 있지 않기 때문에 범위를 설정해놓지 않아야한다.

‍ 코드

import java.io.*;
import java.util.*;

public class Main {
    static int[] arr = {-1,1};
    static int n, m, max = 100000000;

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        StringTokenizer st = new StringTokenizer(br.readLine());
        n = Integer.parseInt(st.nextToken()); //샘터 갯수
        m = Integer.parseInt(st.nextToken()); //지을 집 갯수

        st = new StringTokenizer(br.readLine());
        Queue<Point> q = new LinkedList<>();
        Set<Integer> set = new HashSet<>();
        for (int i = 0; i < n; i++) {
            int x = Integer.parseInt(st.nextToken()); //집 위치
            q.add(new Point(x, 0));
            set.add(x);
        }

        int cnt = 0;
        long result = 0;

        out:while (!q.isEmpty()) {
            Point cp = q.poll();
            for(int i = 0; i < 2; i++) {
                int nx = cp.x + arr[i];

                if(set.contains(nx)) continue;
                result += cp.distance+1;
                cnt++;
                set.add(nx);
                if(cnt == m) break out;
                q.offer(new Point(nx, cp.distance+1));
            }
        }
        System.out.println(result);

    }

    private static class Point {
        private int x;
        private int distance;

        public Point(int x, int distance) {
            this.x = x;
            this.distance = distance;
        }

        @Override
        public String toString() {
            return "Point{" +
                    "x=" + x +
                    ", distance=" + distance +
                    '}';
        }
    }
}