PAT 甲级考试【1003 Emergency】

题目：

As an emergency rescue team leader of a city, you are given a special map of your country. The map shows several scattered cities connected by some roads. Amount of rescue teams in each city and the length of each road between any pair of cities are marked on the map. When there is an emergency call to you from some other city, your job is to lead your men to the place as quickly as possible, and at the mean time, call up as many hands on the way as possible.

Input Specification:

Each input file contains one test case. For each test case, the first line contains 4 positive integers: N (≤500) - the number of cities (and the cities are numbered from 0 to N−1), M - the number of roads, C1 and C2 - the cities that you are currently in and that you must save, respectively. The next line contains N integers, where the i-th integer is the number of rescue teams in the i-th city. Then M lines follow, each describes a road with three integers c1, c2 and L, which are the pair of cities connected by a road and the length of that road, respectively. It is guaranteed that there exists at least one path from C1 to C2.

Output Specification:

For each test case, print in one line two numbers: the number of different shortest paths between C1 and C2, and the maximum amount of rescue teams you can possibly gather. All the numbers in a line must be separated by exactly one space, and there is no extra space allowed at the end of a line.

Sample Input:

Sample Output:

2 4

Dijkstra 算法

Dijkstra（/ˈdikstrɑ/或/ˈdɛikstrɑ/）算法由荷兰计算机科学家 E. W. Dijkstra 于 1956 年发现，1959 年公开发表。是一种求解 非负权图 上单源最短路径的算法。

过程

将结点分成两个集合：已确定最短路长度的点集（记为集合）的和未确定最短路长度的点集（记为集合）。一开始所有的点都属于集合。

初始化，其他点的均为。

然后重复这些操作：

从集合中，选取一个最短路长度最小的结点，移到集合中。
对那些刚刚被加入集合的结点的所有出边执行松弛操作。

直到集合为空，算法结束。

时间复杂度

有多种方法来维护 1 操作中最短路长度最小的结点，不同的实现导致了 Dijkstra 算法时间复杂度上的差异。

暴力：不使用任何数据结构进行维护，每次 2 操作执行完毕后，直接在集合中暴力寻找最短路长度最小的结点。2 操作总时间复杂度为，1 操作总时间复杂度为，全过程的时间复杂度为。
二叉堆：每成功松弛一条边，就将插入二叉堆中（如果已经在二叉堆中，直接修改相应元素的权值即可），1 操作直接取堆顶结点即可。共计次二叉堆上的插入（修改）操作，次删除堆顶操作，而插入（修改）和删除的时间复杂度均为，时间复杂度为。
优先队列：和二叉堆类似，但使用优先队列时，如果同一个点的最短路被更新多次，因为先前更新时插入的元素不能被删除，也不能被修改，只能留在优先队列中，故优先队列内的元素个数是的，时间复杂度为。
Fibonacci 堆：和前面二者类似，但 Fibonacci 堆插入的时间复杂度为，故时间复杂度为，时间复杂度最优。但因为 Fibonacci 堆较二叉堆不易实现，效率优势也不够大¹，算法竞赛中较少使用。
线段树：和二叉堆原理类似，不过将每次成功松弛后插入二叉堆的操作改为在线段树上执行单点修改，而 1 操作则是线段树上的全局查询最小值。时间复杂度为。

在稀疏图中，，使用二叉堆实现的 Dijkstra 算法较 Bellman–Ford 算法具有较大的效率优势；而在稠密图中，，这时候使用暴力做法较二叉堆实现更优。

正确性证明

下面用数学归纳法证明，在 所有边权值非负 的前提下，Dijkstra 算法的正确性²。

简单来说，我们要证明的，就是在执行 1 操作时，取出的结点最短路均已经被确定，即满足。

初始时，假设成立。

接下来用反证法。

设点为算法中第一个在加入集合时不满足的点。因为点一定满足，且它一定是第一个加入集合的点，因此将加入集合前，，如果不存在到的路径，则，与假设矛盾。

于是一定存在路径，其中为路径上第一个属于集合的点，而为的前驱结点（显然）。需要注意的是，可能存在或的情况，即或可能是空路径。

因为在结点之前加入的结点都满足，所以在点加入到集合时，有，此时边会被松弛，从而可以证明，将加入到时，一定有。

下面证明成立。在路径中，因为图上所有边边权非负，因此。从而。但是因为结点在 1 过程中被取出集合时，结点还没有被取出集合，因此此时有，从而得到，这与的假设矛盾，故假设不成立。

因此我们证明了，1 操作每次取出的点，其最短路均已经被确定。命题得证。

注意到证明过程中的关键不等式是在图上所有边边权非负的情况下得出的。当图上存在负权边时，这一不等式不再成立，Dijkstra 算法的正确性将无法得到保证，算法可能会给出错误的结果。

实现

这里同时给出的暴力做法实现和的优先队列做法实现

PAT 甲级考试：

-----dfs+dijkstra算法。

先求出最短路径
再计算出最短路径数目并计算出路径上点权值的最大team和

import java.io.BufferedReader;

import java.io.IOException;

import java.io.InputStreamReader;

import java.util.*;

public class Main {

    static int n, m;

    static int source, target;

    static int[] number;

    static int[][] matrix = new int[500][500];

    static int[] distance;

    static int shorts;

    static int maxpeople = 0;

    static boolean[] traved;

    static List<Integer>[] adj;

    static int ways = 0;

    @SuppressWarnings("unchecked")

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

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        String[] words = br.readLine().split("\\s+");

        n = Integer.valueOf(words[0]);

        m = Integer.valueOf(words[1]);

        source = Integer.valueOf(words[2]);

        target = Integer.valueOf(words[3]);

        number = new int[n];

        words = br.readLine().split("\\s+");

        for (int i = 0; i < n; i++) {

            number[i] = Integer.valueOf(words[i]);

        }

        adj = new ArrayList[n];

        for (int i = 0; i < n; i++) {

            adj[i] = new ArrayList<>();

        }

        for (int i = 0; i < m; i++) {

            int c1, c2, l;

            words = br.readLine().split("\\s+");

            c1 = Integer.valueOf(words[0]);

            c2 = Integer.valueOf(words[1]);

            l = Integer.valueOf(words[2]);

            matrix[c1][c2] = l;

            matrix[c2][c1] = l;

            adj[c1].add(c2);

            adj[c2].add(c1);

        }

        //bfs;

        distance = new int[n];

        Arrays.fill(distance, Integer.MAX_VALUE / 2);

        distance[source] = 0;

        PriorityQueue<Integer> queue = new PriorityQueue<>(new Comparator<Integer>() {

            @Override

            public int compare(Integer o1, Integer o2) {

                return distance[o1] - distance[o2];

            }

        });

        queue.add(source);

        boolean[] visited = new boolean[n];

        while (!queue.isEmpty()) {

            int city = queue.poll();

            if( visited[city]) continue;

            if (distance[city] >= Integer.MAX_VALUE / 2) {

                break;

            }

            visited[city] = true;

            for (int adjcity : adj[city]) {

                if (distance[adjcity] > distance[city] + matrix[city][adjcity]) {

                    distance[adjcity] = distance[city] + matrix[city][adjcity];

                    queue.add(adjcity);

                }

            }

        }

        shorts = distance[target];

        //深度搜索

        traved = new boolean[n];

        traved[source] = true;

        travel(source, 0, number[source], 0);

        System.out.println(allpath.size() + " " + maxpeople);

    }

    static Set<List<Integer>> allpath = new HashSet<>();

    static List<Integer> path = new ArrayList<>();

    static public void travel(int city, int d, int people, int depth) {

        if (city == target && d == shorts) {

            List<Integer> sortedpath = new ArrayList<>();

            for (int x : path) {

                sortedpath.add(x);

            }

            Collections.sort(sortedpath);

            if (!allpath.contains(sortedpath)) {

                ways++;

                allpath.add(sortedpath);

            }

            if (people > maxpeople) {

                maxpeople = people;

            }

            return;

        }

        if (d > shorts) {

            return;

        }

        for (int u : adj[city]) {

            if (!traved[u]) {

                traved[u] = true;

                path.add(u);

                travel(u, d + matrix[city][u], people + number[u], depth + 1);

                traved[u] = false;

                int x = path.remove(depth);

            }

        }

    }

}