过年回家

题目描述

　　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 测试结果