[Java] 백준 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를 출력한다.

예제 입력 1

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

예제 출력 1

NO
YES

 

소스코드

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.StringTokenizer;

public class Main {

	private static BufferedReader bf;
	private static StringTokenizer st;

	private static int TC, N, M, W, result = 0, ret = 0;
	private static List<Road>[] list;
	private static int [] dist;

	static class Road {
		int to, time;	// 목적지, 걸리는 시간

		public Road(int to, int time) {
			super();
			this.to = to;
			this.time = time;
		}

		@Override
		public String toString() {
			return "Road [to=" + to + ", time=" + time + "]";
		}

	}

	public static void main(String[] args) throws NumberFormatException, IOException {
		bf=new BufferedReader(new InputStreamReader(System.in));
		TC=Integer.parseInt(bf.readLine());
		for(int t=1;t<=TC;t++) {
			st=new StringTokenizer(bf.readLine());
			N=Integer.parseInt(st.nextToken());
			M=Integer.parseInt(st.nextToken());
			W=Integer.parseInt(st.nextToken());
			list=new ArrayList[N+1];
			dist=new int[N+1];
			for(int i=1;i<=N;i++) list[i]=new ArrayList<>();
			
			for(int i=0;i<M;i++) {
				st=new StringTokenizer(bf.readLine());
				int S=Integer.parseInt(st.nextToken());
				int E=Integer.parseInt(st.nextToken());
				int T=Integer.parseInt(st.nextToken());
				list[S].add(new Road(E, T));
				list[E].add(new Road(S, T));
			}
			for(int i=0;i<W;i++) {
				st=new StringTokenizer(bf.readLine());
				int S=Integer.parseInt(st.nextToken());
				int E=Integer.parseInt(st.nextToken());
				int T=Integer.parseInt(st.nextToken());
				list[S].add(new Road(E, -1*T));
			}
			
			if(belmanford()) System.out.println("YES");
			else System.out.println("NO");
		}
	}

	public static boolean belmanford() {	// 음수 가중치를 가지므로 벨만 포드 알고리즘을 이용함
		Arrays.fill(dist, 987654321);
		dist[1]=0;	// 시작점 거리 0으로 설정
		boolean isUpdate=false;	// 업데이트 여부를 저장
		
		for(int i=1;i<N;i++) {	// (정점 개수-1)만큼 반복하며 거리 업데이트 확인
			isUpdate=false;
			for(int j=1;j<=N;j++) {	// 정점을 1~N번까지 돌며 연결된 지점 확인
				for(int k=0;k<list[j].size();k++) {
					if(dist[list[j].get(k).to]>dist[j]+list[j].get(k).time) {	// 최단 경로를 저장해줌
						isUpdate=true;
						dist[list[j].get(k).to]=dist[j]+list[j].get(k).time;
					}
				}
			}
		}
		
		if(isUpdate) {	// 거리가 짧아진 경우 N번째에서 최단 경로 업데이트가 한 번 더 일어나는지 확인
			for(int j=1;j<=N;j++) {
				for(int k=0;k<list[j].size();k++) {
					if(dist[list[j].get(k).to]>dist[j]+list[j].get(k).time) {	// 업데이트가 한 번 더 일어난다면 음의 사이클이 생성된 것이므로 시간이 되돌아가는 경우가 발생 가능함
						return true;
					}
				}
			}
		}
		
		return false;
	}
}

벨만 포드 알고리즘 문제를 처음 접해봐서 어려웠으나 해당 알고리즘에 대해 공부하고 나면 이해 가능한 문제였습니다.

벨만 포드 알고리즘은 다익스트라와 유사하지만 음의 가중치를 가진 경우 사용하며, 위의 코드처럼 아무 점에서 시작한다고 가정했을 때 dist 배열을 초기화하는 과정에서 Integer.MAX_VALUE로 설정하지 않는 것에 주의해야 합니다. dist값을 업데이트 하는 과정에서 dist값에 가중치를 더하게 되면 정수 범위를 넘어가게 되기 때문입니다.