260120 : [BOJ 1103] 게임

[sunha20]

🚀 이슈 번호

Resolve: {#2319}

🧩 문제 해결

스스로 해결: ❌

🔎 접근 과정

문제 해결을 위한 접근 방식을 설명해주세요.

• 🔹 어떤 알고리즘을 사용했는지 dfs, dp
• 🔹 어떤 방식으로 접근했는지
  사이클 판정과, 시간 복잡도 줄이는 게 중요한 문제였다.

사이클 판정
단순 dfs에다가, 같은 경로 상에서 방문했던 곳을 또 방문하면 사이클이 생성되므로 -1을 return
(처음에는 연결된 부분 그래프 내의 노드라면 동일한 경로가 아니더라도 0,0로 돌아갈 수 있어서 사이클이 생성된다고 판단했는데, 칸별로 이동 거리가 달라서 0,0에서 왔다고 0,0으로 돌아갈 수 있는 것이 아니라는 것을 간과함)

dp
최장 경로기 때문에, 백트레킹이 불가능하게 코드를 짜면 1->2와 1->3->2 중에 전자가 먼저 처리 되고, 후자는 간과됨 -> 따라서 백트래킹이 가능하게 만들어야함
또한 원래는 dpt값을 인자로 받으면서 갱신해 갔지만, 현재 위치에서 갈수있는 경로를 다 탐색 하고 그 중 최대값을 저장하여서, 중복탐색을 막음

⏱️ 시간 복잡도

시간 복잡도 분석을 작성해주세요.
최악의 경우 수행 시간은 어느 정도인지 분석합니다.

• Big-O 표기법: O(4NM)
• 이유:
  각 이동에 대해 4개의 이동방향이 있고, dp를 통해서 각 칸이 딱 1번만 계산됨(dp가 없으면 4^MN이 되게 됨.)

💻 구현 코드

import java.io.*;

public class Main {

    static int N, M;
    static int[][] board, visited, dp, ofs = {{-1,0}, {1,0}, {0,-1}, {0,1}};

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String[] temp = br.readLine().split(" ");
        N = Integer.parseInt(temp[0]);
        M = Integer.parseInt(temp[1]);
        board = new int[N][M];
        visited = new int[N][M];
        dp = new int[N][M];


        String row;
        for (int n = 0; n < N; n++) {
            row = br.readLine();
            for (int m = 0; m < M; m++) {
                board[n][m] = row.charAt(m) - '0';
            }
        }

        // for -> visit 하지 않은 노드라면 탐색 시작
        visited[0][0] = 1;
        System.out.println(dfs(0, 0));
    }

    static int dfs(int n, int m) {
        dp[n][m] = 1;

        for (int[] o: ofs){
            int nn = n + o[0]*board[n][m];
            int nm = m + o[1]*board[n][m];

            if (check(nn, nm)) {
                // 무한 번이 가능한 경우(사이클 o)
                // -> 같은 경로에서만 체크하기 위해서 아해 visited를 0으로 풀어줘야함.
                // 칸별로 이동 거리가 달라서 0,0에서 왔다고 0,0으로 돌아갈 수 있는 것이 아님.
                if (visited[nn][nm] == 1) {
                    return -1;
                }
                // 사이클 x
                if (visited[nn][nm] == 0) {
                    // 저장된 값 없음
                    if (dp[nn][nm] == 0) {
                        visited[nn][nm] = 1;
                        int result = dfs(nn, nm);

                        if (result == -1) return -1;
                        dp[n][m] = Math.max(dp[n][m], result + 1);  // nn,nm에서 출발한 모든 경우를 탐색하기 때문에, 최대 값이 보장됨.

                        visited[nn][nm] = 0;
                    }
                    // 저장된 값 있음
                    else dp[n][m] = Math.max(dp[n][m], dp[nn][nm]+1);
                }
            }
        }

        return dp[n][m];
    }

    static boolean check(int n, int m) {
        if (n<0) return false;
        if (m<0) return false;
        if (n>=N) return false;
        if (m>=M) return false;

        return board[n][m] != 24;
    }

}