![[백준 / Java] 1865번 : 웜홀](https://img1.daumcdn.net/thumb/R750x0/?scode=mtistory2&fname=https%3A%2F%2Fblog.kakaocdn.net%2Fdn%2Fc2U1BH%2Fbtso0uhZzFR%2FbhdLqLPMqP1HMWBrNjE4ik%2Fimg.jpg)
문제
때는 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
https://www.acmicpc.net/problem/1865
1865번: 웜홀
첫 번째 줄에는 테스트케이스의 개수 TC(1 ≤ TC ≤ 5)가 주어진다. 그리고 두 번째 줄부터 TC개의 테스트케이스가 차례로 주어지는데 각 테스트케이스의 첫 번째 줄에는 지점의 수 N(1 ≤ N ≤ 500),
www.acmicpc.net
문제 풀이
해당 문제는 최단 거리를 구하는 문제이지만, 거리에 음수가 존재하는 문제이다. 최단 거리 문제에서 자주 쓰이는 다익스트라 알고리즘으로 풀게 된다면 일부 케이스에서 오답이 나오게 된다.
그렇기에 음수 거리가 존재하더라도 정답이 나오는 벨만-포드 알고리즘을 사용하여 풀었다. 벨만-포드 알고리즘은 아래 포스트를 참고하면 좋을 것 같다.
2023.07.26 - [algorithm/theory] - 벨만-포트 알고리즘
코드 설명
우선 기존 최단 거리 문제를 풀 듯이 Node class를 생성해주고, 입력으로 주어지는 도로와 웜홀을 ArrayList에 추가해준다.
import java.io.*;
import java.util.*;
public class Main {
public static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
public static BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
public static class Node implements Comparable<Node>{
int distance;
int next;
public Node() {}
public Node(int next, int distance) {
this.distance = distance;
this.next = next;
}
@Override
public int compareTo(Node o) {
return this.distance - o.distance;
}
}
public static ArrayList<ArrayList<Node>> route;
public static int P;
public static int N;
public static int W;
public static int INF = 1_000_000;
public static void main(String[] args) throws IOException {
int T = Integer.parseInt(br.readLine());
for(int t = 0; t < T; t++) {
route = new ArrayList<>();
StringTokenizer st = new StringTokenizer(br.readLine()," ");
P = Integer.parseInt(st.nextToken());
N = Integer.parseInt(st.nextToken());
W = Integer.parseInt(st.nextToken());
for(int i = 0; i <= P; i++) {
route.add(new ArrayList<>());
}
for(int i = 0; i < N; i++) {
StringTokenizer st1 = new StringTokenizer(br.readLine(), " ");
int start = Integer.parseInt(st1.nextToken());
int end = Integer.parseInt(st1.nextToken());
int distance = Integer.parseInt(st1.nextToken());
route.get(start).add(new Node(end,distance));
route.get(end).add(new Node(start,distance));
}
for(int i = 0; i < W; i++) {
StringTokenizer st1 = new StringTokenizer(br.readLine(), " ");
int start = Integer.parseInt(st1.nextToken());
int end = Integer.parseInt(st1.nextToken());
int distance = Integer.parseInt(st1.nextToken());
route.get(start).add(new Node(end,-distance));
}
...
}
...
}
이제 벨만-포드 메서드를 구현해준다.
public static boolean bellmanFord() {
int[] dp = new int[P+1];
Arrays.fill(dp, INF);
dp[1] = 0;
boolean update = false;
for (int i = 1; i < P; i++) {
update = false;
for (int j = 1; j <= P; j++) {
for (Node road : route.get(j)) {
if (dp[road.next] > dp[j] + road.distance) {
dp[road.next] = dp[j] + road.distance;
update = true;
}
}
}
// 더 이상 최단거리 초기화가 일어나지 않았을 경우 반복문을 종료.
if (!update) {
break;
}
}
// (정점의 개수 - 1)번까지 계속 업데이트가 발생했을 경우
// (정점의 개수)번도 업데이트 발생하면 음수 사이클이 일어난 것을 의미함.
if (update) {
for (int i = 1; i <= P; i++) {
for (Node road : route.get(i)) {
if (dp[road.next] > dp[i] + road.distance) {
return true;
}
}
}
}
return false;
}위 코드를 보면 DP을 초기값을 무한으로 설정하고 시작하는 점 1을 0으로 초기화 해준다. 이후 점의 개수 만큼 반복문을 통해 edge relaxation을 실행한다.
이 때 update 변수를 통해 한 edge relaxation에서 변화가 일어나는지 안일어나는지 확인을 한다. 확인을 하는 이유는 더이상 업데이트가 되지 않는다면 negative cycle이 없다는 것이고, 즉 음수 거리가 나오는 곳은 없다는 뜻이기 때문이다.
이와 반대로 점의 개수 만큼 반복을 하여도 업데이트가 발생한다면 이는 negative cycle가 존재한다는 뜻이고, 동시에 거리가 음수인 부분이 나타난다는 뜻이다. 그렇기에 해당 경우를 마지막에 확인하여 negative cycle가 존재한다면 true를 아니라면 false 반환해준다.
반환된 boolean을 통해 정답을 출력하면 된다.
풀이 코드
import java.io.*;
import java.util.*;
public class Main {
public static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
public static BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
public static class Node implements Comparable<Node>{
int distance;
int next;
public Node() {
// TODO Auto-generated constructor stub
}
public Node(int next, int distance) {
this.distance = distance;
this.next = next;
}
@Override
public int compareTo(Node o) {
return this.distance - o.distance;
}
}
public static ArrayList<ArrayList<Node>> route;
public static int P;
public static int N;
public static int W;
public static int INF = 1_000_000;
public static void main(String[] args) throws IOException {
int T = Integer.parseInt(br.readLine());
for(int t = 0; t < T; t++) {
route = new ArrayList<>();
StringTokenizer st = new StringTokenizer(br.readLine()," ");
P = Integer.parseInt(st.nextToken());
N = Integer.parseInt(st.nextToken());
W = Integer.parseInt(st.nextToken());
for(int i = 0; i <= P; i++) {
route.add(new ArrayList<>());
}
for(int i = 0; i < N; i++) {
StringTokenizer st1 = new StringTokenizer(br.readLine(), " ");
int start = Integer.parseInt(st1.nextToken());
int end = Integer.parseInt(st1.nextToken());
int distance = Integer.parseInt(st1.nextToken());
route.get(start).add(new Node(end,distance));
route.get(end).add(new Node(start,distance));
}
for(int i = 0; i < W; i++) {
StringTokenizer st1 = new StringTokenizer(br.readLine(), " ");
int start = Integer.parseInt(st1.nextToken());
int end = Integer.parseInt(st1.nextToken());
int distance = Integer.parseInt(st1.nextToken());
route.get(start).add(new Node(end,-distance));
}
bw.write(bellmanFord() ? "YES" : "NO");
if(t != T -1)bw.write("\n");
}
bw.flush();
bw.close();
}
public static int[] dijkstra(int startPoint) {
PriorityQueue<Node> pq = new PriorityQueue<>();
int[] dp = new int[P+1];
boolean[] visited = new boolean[P+1];
Arrays.fill(dp, INF);
pq.add(new Node(startPoint, 0));
dp[startPoint] = 0;
while(!pq.isEmpty()) {
Node target = pq.poll();
if(visited[target.next]) continue;
visited[target.next] = true;
for(Node next : route.get(target.next)) {
if(dp[target.next] + next.distance < dp[next.next]) {
dp[next.next] = dp[target.next] + next.distance;
pq.add(new Node(next.next,dp[next.next]));
}
}
}
return dp;
}
public static boolean bellmanFord() {
int[] dp = new int[P+1];
Arrays.fill(dp, INF);
dp[1] = 0;
boolean update = false;
for (int i = 1; i < P; i++) {
update = false;
for (int j = 1; j <= P; j++) {
for (Node road : route.get(j)) {
if (dp[road.next] > dp[j] + road.distance) {
dp[road.next] = dp[j] + road.distance;
update = true;
}
}
}
// 더 이상 최단거리 초기화가 일어나지 않았을 경우 반복문을 종료.
if (!update) {
break;
}
}
// (정점의 개수 - 1)번까지 계속 업데이트가 발생했을 경우
// (정점의 개수)번도 업데이트 발생하면 음수 사이클이 일어난 것을 의미함.
if (update) {
for (int i = 1; i <= P; i++) {
for (Node road : route.get(i)) {
if (dp[road.next] > dp[i] + road.distance) {
return true;
}
}
}
}
return false;
}
}'algorithm > problems' 카테고리의 다른 글
| [백준 / Java] 1967번 : 트리의 지름 (0) | 2023.07.29 |
|---|---|
| [백준 / Java] 1918번 후위 표기식 (0) | 2023.07.28 |
| [백준 / Java] 1504번 : 특정한 최단 경로 (0) | 2023.07.24 |
| [백준 / Java] 17626번 Four Squares (0) | 2023.07.23 |
| [프로그래머스 / Javascript] 당구 연습 (1) | 2023.06.16 |