[백준/Java] 13549 숨바꼭질 3

🔗 문제 링크: https://www.acmicpc.net/problem/13549

 

 

🔍 해결 과정

일차원 배열을 활용한 BFS 유형의 문제로 다음과 같은 과정으로 문제를 해결하였습니다.

1️⃣ 각 좌표에 도달할 때 나올 수 있는 최소 시간의 정보를 저장할 정수형 배열 d를 정의한다.
2️⃣ d 테이블의 초기값을 무한으로 초기화해준다. (코드에서는 10억으로 설정)
3️⃣ BFS를 활용하여 왼쪽, 오른쪽, 순간이동 하는 경우에서의 시간을 계산해 준 다음 d 테이블에서 최소 시간을 계속 계산해준다.
4️⃣ BFS 완료후 d 테이블에서 동생이 위치한 d[k] 값을 반환해준다.

 

 

---

✏️ 코드

import java.io.*;
import java.util.ArrayDeque;
import java.util.Arrays;
import java.util.Queue;
import java.util.StringTokenizer;

class Node {
    private final int index;
    private final int time;

    public Node(int index, int time) {
        this.index = index;
        this.time = time;
    }

    public int getIndex() {
        return index;
    }

    public int getTime() {
        return time;
    }
}

public class Main {

    private static final int INF = (int) 1e9;
    private static final int MAX_POS = 100000;

    private static int[] d = new int[200050];

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
        StringTokenizer st = new StringTokenizer(br.readLine());
        int n = Integer.parseInt(st.nextToken()); // n, k의 최댓값: 10만
        int k = Integer.parseInt(st.nextToken());

        bw.write(Integer.toString(findTarget(n, k)));
        bw.flush();
    }

    private static int findTarget(int n, int k) {
        Arrays.fill(d, INF);
        d[n] = 0;
        Queue<Node> q = new ArrayDeque<>();
        q.offer(new Node(n, 0));

        while (!q.isEmpty()) {
            Node cur = q.poll();
            int curIdx = cur.getIndex();
            int curTime = cur.getTime();

            if (d[curIdx] < curTime) {
                continue;
            }
            
            int left = curIdx - 1;
            int leftCost = d[curIdx] + 1;

            int right = curIdx + 1;
            int rightCost = d[curIdx] + 1;

            int doublePos = curIdx * 2;
            int doubleCost = d[curIdx];

            if (left >= 0 && leftCost < d[left]) {
                d[left] = leftCost;
                q.offer(new Node(left, leftCost));
            }

            if (right <= MAX_POS && rightCost < d[right]) {
                d[right] = rightCost;
                q.offer(new Node(right, rightCost));
            }

            if (doublePos <= MAX_POS && doubleCost < d[doublePos]) {
                d[doublePos] = doubleCost;
                q.offer(new Node(doublePos, doubleCost));
            }
        }

        return d[k];
    }
}