過年回家

題目描述

　　NowCoder今年買了一輛新車，他決定本身開車回家過年。回家過程當中要通過n個大小收費站，每一個收費站的費用不一樣，
　　你能幫他計算一下最少須要給多少過路費嗎？

1.1 輸入描述:

　　輸入包含多組數據，每組數據第一行包含兩個正整數m（1≤m≤500）和n（1≤n≤30），其中n表示有n個收費站，
　　編號依次爲一、二、…、n。出發地的編號爲0，終點的編號爲n，即須要從0到n。
　　緊接着m行，每行包含三個整數f、t、c，（0≤f, t≤n; 1≤c≤10），分別表示從編號爲f的地方開到t，須要交c元的過路費。

1.2 輸出描述:

　　對應每組數據，請輸出至少須要交多少過路費。

1.3 輸入例子:

8 4
0 1 10
0 2 5
1 2 2
1 3 1
2 1 3
2 3 9
2 4 2
3 4 4

 

1.4 輸出例子:

7

 

2 解題思路

　　根據題意，能夠根據輸入構造一個有向圖，其中出發地和收費站表示圖的頂點，過路費表示有向邊的權重。要求出發地到終點的最少收費，等價於求起點和終點向短路徑，可使用Dijkstra算法進行處理。

2.1 Dijkstra算法

2.1.1 定義概覽

　　Dijkstra(迪傑斯特拉)算法是典型的單源最短路徑算法，用於計算一個節點到其餘全部節點的最短路徑。主要特色是以起始點爲中心向外層層擴展，直到擴展到終點爲止。Dijkstra算法是頗有表明性的最短路徑算法，在不少專業課程中都做爲基本內容有詳細的介紹，如數據結構，圖論，運籌學等等。注意該算法要求圖中不存在負權邊。
　　問題描述：在無（有）向圖G=(V,E)中，假設每條邊E[i]的長度爲w[i]，找到由頂點V_0到其他各點的最短路徑。（單源最短路徑）

2.1.2 算法描述

　　1) 算法思想：
　　設G=(V,E)是一個帶權有向圖，把圖中頂點集合V分紅兩組，第一組爲已求出最短路徑的頂點集合（用S表示，初始時S中只有一個源點，之後每求得一條最短路徑，就將加入到集合S中，直到所有頂點都加入到S中，算法就結束了），第二組爲其他未肯定最短路徑的頂點集合（用U表示），按最短路徑長度的遞增次序依次把第二組的頂點加入S中。在加入的過程當中，總保持從源點v到S中各頂點的最短路徑長度不大於從源點v到U中任何頂點的最短路徑長度。此外，每一個頂點對應一個距離，S中的頂點的距離就是從v到此頂點的最短路徑長度，U中的頂點的距離，是從v到此頂點只包括S中的頂點爲中間頂點的當前最短路徑長度。
　　2) 算法步驟：
　　a) 初始時，S只包含源點，即S＝{v}，v的距離爲0。U包含除v外的其餘頂點，即:U={其他頂點}，若v與U中頂點u有邊，則<u,v>正常有權值，若u不是v的出邊鄰接點，則<u,v>權值爲∞。
　　b) 從U中選取一個距離v最小的頂點k，把k，加入S中（該選定的距離就是v到k的最短路徑長度）。
　　c) 以k爲新考慮的中間點，修改U中各頂點的距離；若從源點v到頂點u的距離（通過頂點k）比原來距離（不通過頂點k）短，則修改頂點u的距離值，修改後的距離值的頂點k的距離加上邊上的權。
　　d) 重複步驟b和c直到全部頂點都包含在S中。

2.1.3 舉例說明

　　根據例子的輸入構造有向圖，而後使用Dijkstra算法求最短路徑，路徑的構造如圖1所示。

圖1 Dijkstra構造最短路徑

3 算法實現

import java.util.Scanner;

/**
 * Declaration: All Rights Reserved !!!
 */
public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
//        Scanner scanner = new Scanner(Main.class.getClassLoader().getResourceAsStream("data.txt"));

        while (scanner.hasNext()) {

            int line = scanner.nextInt();
            // 收費站的數目加上起點
            int num = scanner.nextInt() + 1;
            int[][] graph = new int[num][num];

            // 初始化圖
            for (int i = 0; i < num; i++) {
                for (int j = 0; j < num; j++) {
                    if (i != j) {
                        graph[i][j] = Integer.MAX_VALUE;
                    }
                }
            }

            // 讀取輸入構造有向圖
            for (int i = 0; i < line; i++) {
                int x = scanner.nextInt();
                int y = scanner.nextInt();
                int v = scanner.nextInt();
                graph[x][y] = v;
            }

            System.out.println(dijkstra(graph));

        }

        scanner.close();
    }

    /**
     * 求起點爲0，終點爲graph.length-1的最短路徑，權重不能爲負數
     *
     * @param graph 有向圖
     * @return 最短路徑，沒有找到返回Integer.MAX_VALUE;
     */
    private static int dijkstra(int[][] graph) {
        // 標記頂點是否已經訪問過
        boolean[] S = new boolean[graph.length];
        // 記錄起點到各點的最短距離
        int[] DIST = new int[graph.length];
        // 記錄前驅頂點，經過找前驅能夠找到從(v, w)的最短路徑的走法
        int[] PREV = new int[graph.length];

        // 處理第一個點
        for (int i = 0; i < graph.length; i++) {
            DIST[i] = graph[0][i];
            // 若是是最大值，說明(0, i)不存在。因此PREV[i]不存在
            if (DIST[i] == Integer.MAX_VALUE) {
                PREV[i] = -1;
            } else {
                PREV[i] = 0;
            }
        }

        // 標記0號頂點已經處理過
        S[0] = true;

        // 處理其他的點
        for (int i = 1; i < S.length; i++) {
            int min = Integer.MAX_VALUE;
            int u = 0;

            // 找未訪問過的頂點j，而且DIST[j]的值最小
            for (int j = 0; j < S.length; j++) {
                if (!S[j] && DIST[j] < min) {
                    u = j;
                    min = DIST[j];
                }
            }

            // 標記u已經被訪問過了
            S[u] = true;

            for (int j = 0; j < S.length; j++) {
                // j沒有被訪問過，而且(u, j)可達
                if (!S[j] && graph[u][j] < Integer.MAX_VALUE) {
                    int v = DIST[u] + graph[u][j];
                    // 從0->...->u->j比0->...->j（其它路徑）短
                    if (v < DIST[j]) {
                        DIST[j] = v;
                        // j是經過u訪問到的
                        PREV[j] = u;
                    }
                }
            }
        }


        return DIST[DIST.length - 1];
    }
}

 

4 測試結果