34-kangrae-jo

[kangrae-jo]

🔗 문제 링크

[웜홀]

✔️ 소요된 시간

40m ~ 1h

✨ 수도 코드

저는 이 문제를 읽고 "음의 사이클"이 있으면 YES고, 아니라면 NO라고 생각하고 그렇게 접근했습니다.
그래서 딱 하나의 알고리즘이 떠오르더라구요.

바로 벨만 포드 알고리즘이죠.
벨만 포드는 최단 경로 알고리즘 중 하나이며, 음의 가중치가 있는 그래프에서도 사용이 가능합니다.

그러나 구현을 하는 방법은 까먹어서... 다시 공부하고 풀어보느라 시간이 오래 걸렸습니다.

벨만 포드 알고리즘의 아이디어는 다음과 같아요.

1. 정점 개수가 N일 때, 최단 경로는 최대N -1개의 간선만 포함할 수 있다.
2. 간선을 N-1번 relax한다면 최단 거리가 완성된다.
3. 만약 N번째에도 거리 갱신이 발생한다면 -> 더 짧은 경로가 계속 생긴다는 것 -> 음수 사이클이 존재한다는 것!

어때요 글로 보니까 이해가 쉽죠?

위에 relaxation이라는 표현이 나왔는데 '완화'라고 합니다.
모든 간선 u ->{ v, w } 에 대해서,

if dist[v] > dist[u] + w
    then dist[v] =dist[u] + w

하는 것을 말합니다.

정점이 N, 간선이 M일때
이 알고리즘은 시간복잡도가 O(NM) 입니다.
매 라운드마다 모든 간선 M개를 훑고 그걸 N-1번 정도 반복하기 때문입니다.
다익스트라보다 느리지만 음수 가중치도 처리 가능하다는 장점이 있죠.

(참고로 pq로 구현한 다익스트라는 O((N + M) log N) 이라고 합니다.)

이번문제는 벨만 포드를 bool타입으로 return 하는 것을 구현할 수 있다면 풀 수 있는 문제였네요.
감사합니다.

📚 새롭게 알게된 내용

벨만 포드 알고리즘을 알게 되었다.
최단 거리를 구하는 기본 연산인 relaxation에 대해서도 알게 되었다.

ㄱㅇㅎ교수님의 자료입니다.
보고 구현을 한건 아니지만 벨만 포드를 이해하는 것에 도움이 되어서 첨부합니다.

자료에서는 N-1번을 고정으로 relax하고,
이후에 한번씩 더 relax해서 true false를 판별하는 군요.

저는 N번 반복하는데, 새로 relax되는 시점이 N번째이면 return true 하도록 했습니다.
취향에 맞게 구현하시면 될 것 같네요.

[g0rnn]

오래 기다리셨죠? ㅋㅋ

전 처음에 경로를 돌아댕기면서 음수가 있는지 확인하려 했습니다. 그런데 생각해보니 사이클이 생기면 모든 경로를 찾을 수가 없죠. 무한대로 생성되잖아요.

그래서 답을 참고했습니다. 벨만 포드 강의자료를 다시 보니 최단 경로를 구하는 것 뿐만 아니라 음수 사이클을 확인할 수가 있더군요. 오히려 음수 사이클을 확인하는 방법처럼 느껴졌습니다. 그동안 다익스트라에 가려져서 신경쓰지 않은 녀석인데 꽤 괜찮은 친구였다는걸 알게 되었어요.

구현은 cpp과 다르게 좀 복잡합니다.. 복잡하다기 보단 보일러 플레이트가 좀 많아요.

package beakjoon;

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

public class Sol1865 {
    private static int tc = 0;

    public static void main(String[] args) throws IOException {
        readInput();
    }

    private static void readInput() throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st;
        tc = Integer.parseInt(br.readLine());

        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < tc; i++) {
            st = new StringTokenizer(br.readLine());
            int n = Integer.parseInt(st.nextToken());
            int m = Integer.parseInt(st.nextToken());
            int w = Integer.parseInt(st.nextToken());

            List<Edge> edges = new ArrayList<>();
            for (int j = 0; j < m; j++) {
                st = new StringTokenizer(br.readLine());
                int s = Integer.parseInt(st.nextToken());
                int e = Integer.parseInt(st.nextToken());
                int t = Integer.parseInt(st.nextToken());

                edges.add(new Edge(s, e, t));
                edges.add(new Edge(e, s, t));
            }

            for (int j = 0; j < w; j++) {
                st = new StringTokenizer(br.readLine());
                int s = Integer.parseInt(st.nextToken());
                int e = Integer.parseInt(st.nextToken());
                int t = Integer.parseInt(st.nextToken());

                edges.add(new Edge(s, e, -t));
            }

            sb.append(hasNegativeCycle(edges, n) ? "YES" : "NO").append('\n');
        }
        System.out.println(sb.toString());
        br.close();
    }

    private static boolean hasNegativeCycle(List<Edge> edges, int n) {
        int[] dist = new int[n + 1]; // 1에서 출발!
        Arrays.fill(dist, 0);

        for (int i = 1; i < n; i++) {
            boolean updated = false;
            for (Edge e : edges) {
                if (dist[e.to] > dist[e.from] + e.time) {
                    dist[e.to] = dist[e.from] + e.time;
                    updated = true;
                }
            }
            if (!updated) break;
        }
        for (Edge e : edges) {
            if (dist[e.to] > dist[e.from] + e.time) return true;
        }
        return false;
    }

    static class Edge {
        int from;
        int to;
        int time;

        Edge(int f, int t, int time) {
            from = f;
            to = t;
            this.time = time;
        }
    }
}

근데 특이한게 이녀석은 음수 사이클을 찾는데에만 특화되어 있더라구요. 그래서 음수 여부와 상관없이 사이클을 찾을 수 있는 방법이 궁금해졌습니다.

찾아보니 이는 유니온 파인드를 이용하더라구요. 이것도 벨만 포드와 비슷하게 엣지별로 수행합니다. 엣지를 순회하며 u, v를 union(집합을 결합)하다가 u와 v의 root parent가 같으면 사이클로 판별합니다. 수도코드를 적어둘테니 참고하시조

for (auto u, v : edges) {
    if (!union(u, v)) {
        hasCycle = true;
        break;
    }
}

union(int u, int v) {
    parent_u = findParent(u);
    parent_v = findParent(v);
    if (parent_u == parent_v) return false; // 사이클 발생

    parent[u] = v; // 서로 다른 집합이므로 두 집합을 합침
    return true;
}