32-InSange

[InSange]

🔗 문제 링크

Minimum Time to Visit a Cell In a Grid

✔️ 소요된 시간

5시간

✨ 수도 코드

개요

m, n의 크기를 지니고 음의 정수를 제외한 요소들로 구성된 그리드가 존재한다.
0, 0에서 사용자가 출발하여 m-1, n-1의 위치로 이동할 때
상, 하, 좌, 우 로 이동할 수 있으며 한 번의 이동당 시간이 1씩 오르며 각 요소의 숫자가 현재 이동한 시간 Time 보다 작거나 같아야 해당 요소의 칸으로 이동이 가능하다.

즉, Time 보다 작거나 같을 때 해당 요소의 노드로 이동이 가능.
만약 도달할 수 있는 경우의 수가 없다면 -1을 리턴

접근 방식

우선 여타 일반 BFS의 문제랑 다름 없다.
문제를 읽었을 때 경로를 찾는 문제이기 때문에 DFS, BFS로 좁힐 수 있으며 넓이는 10^5인 점을 감안하면 DFS로는 시간 초과가 날 것이기에 BFS로 접근했다.

여기서 관점은 타 지점으로 이동하기 위해 반복적인 노드를 왔다갔다해서 시간을 버티는 방법을 어떻게 표현하면 좋을까 였다.

즉.

위의 예시를 바탕으로 0, 0에서 Time = 0 일 때 고려를 해보면
오른쪽 1로 이동시 Time = 1이 되고 Time과 요소는 같기 때문에 이동이 가능.
t = 1, we move to the cell (0,1). It is possible because grid[0][1] <= 1. 이렇게 표현을 한다고 하였을 때

• at t = 0, we are on the cell (0,0).
• at t = 1, we move to the cell (0,1). It is possible because grid[0][1] <= 1.
• at t = 2, we move to the cell (1,1). It is possible because grid[1][1] <= 2.
• at t = 3, we move to the cell (1,2). It is possible because grid[1][2] <= 3.
• at t = 4, we move to the cell (1,1). It is possible because grid[1][1] <= 4.
• at t = 5, we move to the cell (1,2). It is possible because grid[1][2] <= 5.
• at t = 6, we move to the cell (1,3). It is possible because grid[1][3] <= 6.
• at t = 7, we move to the cell (2,3). It is possible because grid[2][3] <= 7.

전체 이동 노선과 Time을 표현하면 이렇다.
여기서 (1,2) = 2 에서 (1,3) = 5로 이동하는 부분을 살펴보면
처음 (1,2)에 진입했을 때의 시각은 3이다. 그러나 (1,3)의 요소 값은 5이기에 시간이 부족하다.
시간을 채우기 위해 이전의 노드를 반복 방문하면서 5보다 크거나 같을 때 까지 시간을 때운다.
(1,2) -> (1,1) -> (1,2) -> (1,3)
T:3 4 5 6
이런 식으로 말이다.

이 부분을 표현하기 위해서 고민을 많이 했다.
특히 시간을 표현해주기 위해서 visited (여기선 val) 2차원 배열을 bool 형식이 아닌 int 형식으로 지정해 내가 지나갔던 시간을 중점으로 기록하며 나갔다.

그러나 예외 처리가 까다로웠다.
특히 반복하는 지점을 최소로 맞춰야할지, 최대로 업데이트를 해야할지 고민에 빠진 것이다.
최소 경로를 찾기 위해 이미 방문했던 경로는 재 방문하는 것이 불가능하지만 여기는 시간을 때우기 위해 재 방문으로 해야하는 것이었다.
하지만 재방문을 허락하게 된다면 시간 초과가 날 것이 분명했기에 일반적인 큐가 아닌 우선 순위 큐를 활용하여 가장 작은 시간을 지닌 노드들 부터 탐색하는 방식이다.

우선 순위 큐에 들어가는 요소는 배열로 지정하여 {Time, Y, X} 를 넣어 Time을 중점으로 가장 짧은 Time을 지닌 지점부터 방문하는 것이었다.
그리고 Time보다 큰 요소들의 지점은 방문하지 않고 그 주변의 방문 가능한 요소들에서 1씩 값을 올린 후 업데이트 하는 방식으로 설정하는 것이었다.

이런 식으로 말이다!
하지만 문제점은 예외 처리를 해결하지 못한 것이었다.
T값을 올려 해결할 수 있지만 그 이전에 방문했던 노드들 역시 값이 업데이트되기 때문에 시간 초과가 발생할 수 밖에 없다...

그래서 힌트를 참고했을 때
그냥 기록되는 시간 자체를 계산해버리는 것이었다..!

여기서 뒤통수를 맞은 느낌이었다.
늘 풀어오던 그래프의 문제는 순차적으로 방문하기 때문에 늘 1의 값만 증가해오던 관념에 사로잡혀 수학적으로 접근하지 못한 것이었다..!

int nextTime = max(curTime + 1, grid[nextY][nextX] + ((grid[nextY][nextX] - curTime) % 2 == 0 ? 1 : 0));

다음 시간을 현재 시간 + 1 을 한 것과 인접 노드가 지닌 요소 값 - 현재 시간 을 2로 나눈 나머지의 값을 바탕으로 값을 설정해버리면 내가 고민하던 것들이 해결된다.
즉, 일일이 다시 방문하면서 우선 순위큐에 집어 넣는 게 아닌. 한 번에 계산 처리를 함으로써 중복적으로 발생하는 방문 경로를 축약시킨 것이다.

여기서 잘 잡아야 되는 부분은 바로 인접 노드의 나머지 시간이 홀수냐 짝수냐에 따라 0과 1이 결정되는 점이다.

만약 짝수의 경우를 고려해보자.

2에서 4의 요소로 넘어 갈 경우. 4는 Time이 4이상일 때 방문이 가능하다. 그러나 2의 요소에 도달했을 때 Time은 2이다.
인접 요소 4 - 2(Time)을 하면 2로 짝수이다.
이제 알겠는가? 2에서 4로 넘어갈려면 2번의 타임을 건너야 한다.
즉. 2에서 1로 한번 갔다가 2로 다시 돌아오는 시점 이후 방문이 가능하다.
그럼 2일 때 Time은 2, 1일 때 Time은 3, 2일 때 Time은 4이기에 이후에 4에 방문할 수 있는데 여기서 4에 도달하게 되면 Time은 4이다.
그렇기 때문에 짝수의 경우 1을 다음 인접한 노드에 더해 줌으로써 반복의 경우의 수를 더해 준 것으로 볼 수 있다.

5의 경우 일때도 5 - 2는 3으로 홀수이기에 인접 노드 5에 방문 Time은 5로 그 자체의 값이 다음 방문 시간이 된다.

마지막으로 여기서 가장 중요한 예외는 경로가 없는 것인데.
이 예외 케이스는 시작할 때 말고는 없는 것 같다.
시작할 때 이동할 수 있는 노드가 존재한다면 거기서 다음 노드까지 무한정 반복해주면 이동 못하는 곳이 없을 것이다.

고로 0,0에서 출발할 때 오른쪽, 아래 노드가 2 미만 이기만하면 무조건 통과할 수 있기에 맨 처음에 예외 사항만 잘 체크해주면 된다!

if(grid[0][1] > 1 && grid[1][0] > 1) // 갈 수 있는 길이 처음부터 없으면
        {
            return -1;
        }

소스 코드

class Solution {
public:
    int minimumTime(vector<vector<int>>& grid) {
        if(grid[0][1] > 1 && grid[1][0] > 1) // 갈 수 있는 길이 처음부터 없으면
        {
            return -1;
        }
        
        int row = grid.size();
        int col = grid[0].size();

        vector<vector<int>> val;
        val.assign(row, vector<int>(col, INT_MAX));
        
        priority_queue<vector<int>, vector<vector<int>>, greater<>> pq;
        int dy[4] = {0, 0, -1, 1};
        int dx[4] = {1, -1, 0, 0};
        
        pq.push({0, 0, 0});
        val[0][0] = 0;
        
        while(!pq.empty())
        {
            int curY = pq.top()[1];
            int curX = pq.top()[2];
            int curTime = pq.top()[0];
            pq.pop();
            
            if(curY == row-1 && curX == col-1)
            {
                return curTime;
            }
            
            for(int i = 0; i < 4; i++)
            {
                int nextY = curY + dy[i];
                int nextX = curX + dx[i];
                
                if(nextY < 0 || nextY >= row || nextX < 0 || nextX >= col) continue; // Out of Bounds
                int nextTime = max(curTime + 1, grid[nextY][nextX] + ((grid[nextY][nextX] - curTime) % 2 == 0 ? 1 : 0));
                
                if(val[nextY][nextX] > nextTime)
                {
                    pq.push({nextTime, nextY, nextX});             
                    val[nextY][nextX] = nextTime;
                }
            }
        }
        
        return -1;
    }
};

📚 새롭게 알게된 내용

아마 가장 쉽게 풀 수 있었음에도 나 같은 사람들을 골려주기 위해 준비한 문제가 아닐까 싶다... 제작자의 의도에 제대로 놀아난 것 같다!