【编程马拉松】【016-过年回家】

编程马拉松算法目录】


【016-过年回家】【工程下载>>>】


1 题目描述


  NowCoder今年买了一辆新车,他决定自己开车回家过年。回家过程中要经过n个大小收费站,每个收费站的费用不同,
  你能帮他计算一下最少需要给多少过路费吗?

1.1 输入描述:


  输入包含多组数据,每组数据第一行包含两个正整数m(1≤m≤500)和n(1≤n≤30),其中n表示有n个收费站,
  编号依次为1、2、…、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;

/**
 * Author: 王俊超
 * Time: 2016-05-11 19:56
 * CSDN: http://blog.csdn.net/derrantcm
 * Github: https://github.com/Wang-Jun-Chao
 * 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 测试结果


这里写图片描述

5 其它信息


因为markddow不好编辑,因此将文档的图片上传以供阅读。Pdf和Word文档可以在Github上进行【下载>>>】。

赞 (0) 评论 分享 ()