[백준 P1865] 웜홀 Java

P1865 웜홀

1865번: 웜홀

문제

때는 2020년, 백준이는 월드나라의 한 국민이다. 월드나라에는 N개의 지점이 있고 N개의 지점 사이에는 M개의 도로와 W개의 웜홀이 있다. (단 도로는 방향이 없으며 웜홀은 방향이 있다.) 웜홀은 시작 위치에서 도착 위치로 가는 하나의 경로인데, 특이하게도 도착을 하게 되면 시작을 하였을 때보다 시간이 뒤로 가게 된다. 웜홀 내에서는 시계가 거꾸로 간다고 생각하여도 좋다.

시간 여행을 매우 좋아하는 백준이는 한 가지 궁금증에 빠졌다. 한 지점에서 출발을 하여서 시간여행을 하기 시작하여 다시 출발을 하였던 위치로 돌아왔을 때, 출발을 하였을 때보다 시간이 되돌아가 있는 경우가 있는지 없는지 궁금해졌다. 여러분은 백준이를 도와 이런 일이 가능한지 불가능한지 구하는 프로그램을 작성하여라.

입력값

첫 번째 줄에는 테스트케이스의 개수 TC(1 ≤ TC ≤ 5)가 주어진다. 그리고 두 번째 줄부터 TC개의 테스트케이스가 차례로 주어지는데 각 테스트케이스의 첫 번째 줄에는 지점의 수 N(1 ≤ N ≤ 500), 도로의 개수 M(1 ≤ M ≤ 2500), 웜홀의 개수 W(1 ≤ W ≤ 200)이 주어진다. 그리고 두 번째 줄부터 M+1번째 줄에 도로의 정보가 주어지는데 각 도로의 정보는 S, E, T 세 정수로 주어진다. S와 E는 연결된 지점의 번호, T는 이 도로를 통해 이동하는데 걸리는 시간을 의미한다. 그리고 M+2번째 줄부터 M+W+1번째 줄까지 웜홀의 정보가 S, E, T 세 정수로 주어지는데 S는 시작 지점, E는 도착 지점, T는 줄어드는 시간을 의미한다. T는 10,000보다 작거나 같은 자연수 또는 0이다.

두 지점을 연결하는 도로가 한 개보다 많을 수도 있다. 지점의 번호는 1부터 N까지 자연수로 중복 없이 매겨져 있다.

2
3 3 1
1 2 2
1 3 4
2 3 1
3 1 3
3 2 1
1 2 3
2 3 4
3 1 8

출력값

TC개의 줄에 걸쳐서 만약에 시간이 줄어들면서 출발 위치로 돌아오는 것이 가능하면 YES, 불가능하면 NO를 출력한다.

NO
YES

알고리즘

문제를 분석해보자.

우선 월드나라는 도로와 웜홀이 있다. 도로는 양방향으로 이동이 가능하고, 웜홀은 한 방향으로만 이동해야 한다. 웜홀은 매우 특이하게도, 시계가 거꾸로 간다. (매우 특이하네)

 

백준이는 한 지점에서 출발하여 다시 출발 위치로 돌아왔을 때, 출발을 하였을 때보다 시간이 되돌아가는 경우가 있는지 알고 싶어한다.

조금 알고리즘 틱한 말로 바꾸어보면, 결국 음의 싸이클이 존재하는지를 찾으면 된다.

 

음의 간선이 존재하고 음의 싸이클을 찾아내야 하기 때문에 벨만 포드 알고리즘을 사용한다. 정점이 N개라고 할 때, N-1번 동안 모든 간선을 순회하면서 가중치를 업데이트하고, 마지막 한 번의 순회를 더 거쳤을 때 가중치가 순회된다면 음의 싸이클이 있다고 판단하면 된다.

여기서 문제가 하나 발생한다. 시작 정점이 따로 명시되어 있지 않아서, 모든 정점에서 벨만포드 알고리즘을 돌려야 한다는 점이다. 그래서 최악의 경우 N 개의 정점을 N 번 동안 순회하면서 M개의 간선의 가중치를 다 적용해야 하므로 N * N * M 만큼의 시간 복잡도가 소요되고 너무 오래 걸릴 것으로 판단했다.

 

N개의 정점을 모두 순회해야 하는 이유는 이러한 경우가 있을 수 있기 때문이다. 아래의 상황에서는 1번 정점에서 벨만포드 알고리즘을 수행하면 음의 싸이클이 없다고 판단하는데, 4번과 5번 정점에 실제로 음의 싸이클이 존재하고 있다.

 

그래서 기존의 벨만포드 알고리즘에서 한 부분을 수정했다. 원래의 벨만포드에서는 시작할 때 가중치를 업데이트 하는 배열(여기서는 path 배열)을 INF 값으로 초기화하고 시작점의 가중치를 0으로 수정하고 가중치를 업데이트 한다. 그리고 모든 간선을 순회하면서 간선의 출발지까지 갈 수 있고, 저장되어있는 가중치보다 더 작은 가중치로 목적지까지 갈 수 있는 경우에 가중치를 업데이트 한다. 이를 코드로 바꾸면 다음과 같다.

if (path[edge[0]] != INF) {
    if (path[edge[0]] > path[i] + edge[1]) {
        path[edge[0]] = path[i] + edge[1];
    }
}

여기서 간선의 출발지로 갈 수 없는 경우에는 탐색을 하지 않기 때문에, 위와 같은 상황에서 1번 정점을 출발지로 한다면, 4와 5번 정점에 대한 탐색이 이루어지지 않게된다. 그래서 갈 수 있는지 판단하는 부분을 삭제했다.

if (path[edge[0]] > path[i] + edge[1]) {
    path[edge[0]] = path[i] + edge[1];
}

이런 경우에 설령 1번 정점에서 4번까지 가는 경로가 없지만 (INF 값이지만), 일단 4번에 갈 수 있다고 가정하고 4번과 5번 경로 값을 INF에 더해서 업데이트 해야하는 경우에만 업데이트를 한다. 이때 path[4]와 path[5]에는 INF 값이 저장되어 있지만, “path[5] > path[4] - 1”이 성립하기 때문에 path[5] 는 INF - 1로 업데이트 된다. 물론 4번과 5번 정점 사이 간선의 가중치가 양수라면 “path[5] < path[4] + 간선의 가중치” 이기 때문에 path[5]는 업데이트 되지 않는다.

 

이런 방법으로 N - 1번 동안 모든 간선을 순회하며 업데이트한 이후에 마지막으로 간선 업데이트를 진행할 경우 음의 싸이클을 찾을 수 있다. 즉, 원래는 갈 수 없는 정점이라도, 음의 싸이클이 존재하는지 여부를 찾는 것이 문제의 목적이므로 일단 갈 수 있다고 가정하고 탐색을 진행해야 한다. 이 경우에는 N * M - 1번의 시간 복잡도로 결과를 찾아낼 수 있다.

코드

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

public class Main {
    static final int INF = Integer.MAX_VALUE;

    static int TC;
    static int N, M, W;
    static List<int[]>[] graph;
    static long[] path;

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

        TC = Integer.parseInt(br.readLine());

        for (int tc = 1 ; tc <= TC ; tc++) {
            st = new StringTokenizer(br.readLine());

            N = Integer.parseInt(st.nextToken());
            M = Integer.parseInt(st.nextToken());
            W = Integer.parseInt(st.nextToken());

            graph = new ArrayList[N + 1];
            path = new long[N + 1];

            Arrays.fill(path, INF);

            for (int i = 1; i <= N; i++) {
                graph[i] = new ArrayList<>();
            }

            for (int i = 0; i < M; i++) {
                st = new StringTokenizer(br.readLine());
                int from = Integer.parseInt(st.nextToken());
                int to = Integer.parseInt(st.nextToken());
                int weight = Integer.parseInt(st.nextToken());

                graph[from].add(new int[] {to, weight});
                graph[to].add(new int[] {from, weight});
            }

            for (int i = 0; i < W; i++) {
                st = new StringTokenizer(br.readLine());
                int from = Integer.parseInt(st.nextToken());
                int to = Integer.parseInt(st.nextToken());
                int weight = Integer.parseInt(st.nextToken());

                graph[from].add(new int[] {to, -1 * weight});
            }

            path[1] = 0;
            System.out.println(bellman() ? "YES" : "NO");
        }
    }

    public static boolean bellman() {
        for (int j = 0; j < N - 1; j++) {
            for (int i = 1; i <= N; i++) {
                for (int[] edge : graph[i]) {
                    if (path[edge[0]] > path[i] + edge[1]) {
                        path[edge[0]] = path[i] + edge[1];
                    }
                }
            }
        }

        for (int i = 1 ; i <= N; i++) {
            for (int[] edge : graph[i]) {
                if (path[edge[0]] > path[i] + edge[1]) {
                    return true;
                }
            }
        }

        return false;
    }
}