[boj 1865] 웜홀 - Java

💡https://www.acmicpc.net/problem/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까지 자연수로 중복 없이 매겨져 있다.

출력

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

 

문제 톺아보기

해당 문제는 노드 간 거리를 구하는데 음의 가중치를 지닌 edge가 존재한다.

노드 간 최단 거리를 구하는 알고리즘이 BFS, 다익스트라, 벨만-포드, 플루이드 워셜 정도를 생각할 수 있다.

BFS는 가중치가 모든 edge가 같아야 하고 다익스트라는 음수인 가중치가 있으면 안된다. 플루이드 워셜은 O(N^3)이니까 안된다.

그럼 벨만-포드를 사용해야하는데 문제에서 원하는 경우는 출발지점으로 돌아왔을 때 시간이 되돌아간 경우를 생각해야 한다. 요고는 음의 사이클이 발생한 경우를 의미한다. 왜 그럴까? 간단하게 출발지로 다시 돌아온다는 의미가 사이클이 존재해야 한다는 의미이다. 근데 시간이 처음보다 되돌아가기 위해선 무조건 사이클 상에 하나의 음의 가중치를 가진 edge가 필요하다는 의미이고 음의 가중치를 지닌 edge가 하나라도 사이클에 존재하면 그건 음의 사이클이라서 돌면 돌수록 최단 거리가 더 짧아진다.

그럼 문제를 풀기 위해선 음의 사이클이 있는지 여부만 파악하면 된다. 음의 사이클이 존재하면 YES, 존재하지 않으면 NO이다.

 

문제에서 원하는 것은 모든 노드에서 출발해봤을 때 음의 사이클이 생기는지 여부를 파악해야 한다. 하지만 이걸 그대로 풀어버리면 O(N * NE) 일 것이고 이는 약 5억으로 시간이 초과될 것이다. 그럼 여기서 줄일 수 있는 것은 뭘까? 모든 노드가 아니라 임의의 하나의 노드에서만 출발해도 음의 사이클을 찾을 수 있다는 것이다.

 

이 문제가 원하는 것은 특정 노드에서 노드까지의 최단 거리가 아니기 때문에 선정한 임의의 노드와 edge로 연결되어있는 노드들만 탐색이 가능하지 않아도 되고 모든 노드에서 인접한 노드 간 경로에서 음의 사이클이 존재하는지 여부만 파악하면 된다.

---

구현 코드

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

public class Main {
    private static final int INF = 987654321;
    
    private static int n, m, w, tc;
    private static List<List<Edge>> edges;
    
    public static void main(String args[]) throws IOException {
        printResultAfterSimulate();
    }
    
    private static void printResultAfterSimulate() throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringBuilder sb = new StringBuilder();
        
        tc = Integer.parseInt(br.readLine());
        while(tc-- > 0) {
            initialize(br);
            sb.append(bellmanFord(0));
            sb.append("\n");
        }
        System.out.println(sb.toString());
    }
    
    private static void initialize(BufferedReader br) throws IOException {
        String[] tmp = br.readLine().split(" ");
        n = Integer.parseInt(tmp[0]);
        m = Integer.parseInt(tmp[1]);
        w = Integer.parseInt(tmp[2]);
        
        edges = new ArrayList<>();
        for (int i = 0 ; i < n; i++) {
            edges.add(new ArrayList<>());
        }
        
        for (int i = 0; i < m; i++) {
            tmp = br.readLine().split(" ");
            int s = Integer.parseInt(tmp[0]) - 1;
            int e = Integer.parseInt(tmp[1]) - 1;
            int t = Integer.parseInt(tmp[2]);
            edges.get(s).add(new Edge(e, t));
            edges.get(e).add(new Edge(s, t));
        }
        
        for (int i = 0; i < w; i++) {
            tmp = br.readLine().split(" ");
            int s = Integer.parseInt(tmp[0]) - 1;
            int e = Integer.parseInt(tmp[1]) - 1;
            int t = Integer.parseInt(tmp[2]);
            edges.get(s).add(new Edge(e, -t));
        }
    }
    
    private static String bellmanFord(int start) {
        int[] distance = new int[n];
        Arrays.fill(distance, INF);
        
        distance[start] = 0;
        for (int i = 0; i < n - 1; i++) {
            for (int j = 0; j < n; j++) {
                for (Edge e : edges.get(j)) {
                    if (distance[e.node] > distance[j] + e.dist) {
                        distance[e.node] = distance[j] + e.dist;
                    }
                }
            }
        }
        
        if (checkNegativeCycle(distance)) {
            return String.format("YES");
        }
        return String.format("NO");
    }
    
    private static boolean checkNegativeCycle(int[] distance) {
        for (int j = 0; j < n; j++) {
            for (Edge e : edges.get(j)) {
                if (distance[e.node] > distance[j] + e.dist) {
                    return true;
                }
            }
        }
        return false;
    }
}

class Edge {
    int node;
    int dist;
    
    Edge(int node, int dist) {
        this.node = node;
        this.dist = dist;
    }
}

 

Reference

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

[BOJ] 백준 1865번 : 웜홀 (JAVA)