[Algorithm][JAVA] 백준 11780번: 플로이드 2

https://www.acmicpc.net/problem/11780

11780번: 플로이드 2

 

 

---

문제

n(1 ≤ n ≤ 100)개의 도시가 있다.

그리고 한 도시에서 출발하여 다른 도시에 도착하는 m(1 ≤ m ≤ 100,000)개의 버스가 있다.

각 버스는 한 번 사용할 때 필요한 비용이 있다.

모든 도시의 쌍 (A, B)에 대해서 도시 A에서 B로 가는데 필요한 비용의 최솟값을 구하는 프로그램을 작성하시오.

 

입력

첫째 줄에 도시의 개수 n이 주어지고 둘째 줄에는 버스의 개수 m이 주어진다.

그리고 셋째 줄부터 m+2줄까지 다음과 같은 버스의 정보가 주어진다.

먼저 처음에는 그 버스의 출발 도시의 번호가 주어진다.

버스의 정보는 버스의 시작 도시 a, 도착 도시 b, 한 번 타는데 필요한 비용 c로 이루어져 있다.

시작 도시와 도착 도시가 같은 경우는 없다. 비용은 100,000보다 작거나 같은 자연수이다.

 

출력

먼저, n개의 줄을 출력해야 한다. i번째 줄에 출력하는 j번째 숫자는 도시 i에서 j로 가는데 필요한 최소 비용이다.

만약, i에서 j로 갈 수 없는 경우에는 그 자리에 0을 출력한다.

그 다음에는 n×n개의 줄을 출력해야 한다.

i×n+j번째 줄에는 도시 i에서 도시 j로 가는 최소 비용에 포함되어 있는 도시의 개수 k를 출력한다.

그 다음, 도시 i에서 도시 j로 가는 경로를 공백으로 구분해 출력한다.

이때, 도시 i와 도시 j도 출력해야 한다. 만약, i에서 j로 갈 수 없는 경우에는 0을 출력한다.

 

문제 접근

플로이드 와샬 (Floyd Warshall) 알고리즘

 

- 모든 최단 경로를 구하는 알고리즘

- 이 알고리즘을 한 번 실행하여 모든 노드 간 최단 경로(모든 정점에서 모든 정점까지의 최단 거리)를 구할 수 있다. 

- 노드를 선택하고 더 짧은 길이를 선택하여 줄이는 과정을 반복

- 플로이드 와샬 알고리즘은 '거쳐가는 정점'을 기준으로 최단 거리를 구하는 것!

- 알고리즘을 사용할 때 반복문을 세 개 사용 

  1) 첫 번째 반복문: 중간에 거쳐가는 정점 

  2) 두 번째 반복문: 출발하는 정점 

  3) 세 번째 반복문: 도착하는 정점

 

코드

코드 출처: https://zoosso.tistory.com/377

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Stack;
import java.util.StringTokenizer;
 
public class Main {
    public static final int INF = 1000000;
    public static final int NIL = -1;
    public static int N, M;
    public static int[][] dist;
    public static int[][] next;
    public static Stack<Integer> path;
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = null;
         
        N = Integer.parseInt(br.readLine());
        dist = new int[N + 1][N + 1];
        next = new int[N + 1][N + 1];
         
        for(int i=1; i<=N; i++) {
            for(int j=1; j<=N; j++) {
                next[i][j] = NIL;
                if(i == j) continue;
                dist[i][j] = INF;
            }
        }
         
        M = Integer.parseInt(br.readLine());
        while (M-- > 0) {
            st = new StringTokenizer(br.readLine());
            int u = Integer.parseInt(st.nextToken());
            int v = Integer.parseInt(st.nextToken());
            int cost = Integer.parseInt(st.nextToken());
            dist[u][v] = Math.min(dist[u][v], cost);
            next[u][v] = u;
        }
         
        // 플로이드 와샬 알고리즘
        floydWarshall();
         
        // 정답출력
        printAnswer();
    }
     
    public static void floydWarshall() {
        // 중간에 거쳐가는 정점 (k)
        for(int k = 1; k <= N; k++) {
            // 출발 정점 (i)
            for(int i=1; i <= N; i++) {
                // 도착 정점 (j)
                for(int j=1; j <= N; j++) {
                    if(dist[i][j] > dist[i][k] + dist[k][j]) {
                        // 기존에 저장된 최단 거리와 정점 k를 거쳐가는 (i → k) + (k → j) 경로 중 최소값
                        dist[i][j] = dist[i][k] + dist[k][j];
                        // 중간 경로로 정점 k를 거쳐가도록 갱신
                        next[i][j] = next[k][j]; 
                    }
                }
            }
        }
    }
     
    public static void printAnswer() {
        StringBuilder sb = new StringBuilder();
        // 최단 거리 비용
        for(int i=1; i <= N; i++) {
            for(int j=1; j <= N; j++) {
                if(dist[i][j] >= INF) sb.append("0 ");
                else sb.append(dist[i][j] + " ");
            }
            sb.append("\n");
        }
         
        // 최단 거리 경로
        for(int i=1; i <= N; i++) {
            for(int j=1; j <= N; j++) {
                // i == j로 자기자신이거나 i → j 가는 경로가 전혀 없는 경우
                if(next[i][j] == NIL) sb.append("0\n");
                else {
                    path = new Stack<>();
                    int pre = j;
                    path.add(j); // 거쳐가는 정점
                    while(i != next[i][pre]) { // 도착 정점까지
                        pre = next[i][pre];
                        path.push(pre);
                    }
                    // 최단 거리 경로 크기 (출발 정점까지 포함)
                    sb.append(path.size()+1 + " ");
                    sb.append(i + " ");
                    while(!path.empty()) {
                        sb.append(path.pop() + " ");
                    }
                    sb.append("\n");
                }
            }
        }
        System.out.println(sb.toString());
    }
}

 

플로이드 와샬 알고리즘은 이해했지만 코드는 완전히 다 이해하지 못했다...

주석을 보고 어렴풋이 이해는 했지만 나보고 직접 작성하라고 하면 못하는 상태다 ^..^

이 코드를 완전히 이해하고 직접 작성할 수 있을 때까지 많은 공부가 필요할 것 같다...