蓝桥杯_算法提高_道路与航道（典型的SPFA算法问题）

问题描述
农夫约翰正在针对一个新区域的牛奶配送合同进行研究。他打算分发牛奶到T个城镇（标号为1..T），
这些城镇通过R条标号为（1..R）的道路和P条标号为（1..P）的航路相连。
每一条公路i或者航路i表示成连接城镇Ai（1<=A_i<=T）和Bi（1<=Bi<=T）代价为Ci。
每一条公路，Ci的范围为0<=Ci<=10,000；由于奇怪的运营策略，每一条航路的Ci可能为负的，也就是-10,000<=Ci<=10,000。
每一条公路都是双向的，正向和反向的花费是一样的，都是非负的。
每一条航路都根据输入的Ai和Bi进行从Ai->Bi的单向通行。
实际上，如果现在有一条航路是从Ai到Bi的话，那么意味着肯定没有通行方案从Bi回到Ai。
农夫约翰想把他那优良的牛奶从配送中心送到各个城镇，当然希望代价越小越好，你可以帮助他嘛？配送中心位于城镇S中（1<=S<=T）。

输入格式
输入的第一行包含四个用空格隔开的整数T，R，P，S。
接下来R行，描述公路信息，每行包含三个整数，分别表示Ai，Bi和Ci。
接下来P行，描述航路信息，每行包含三个整数，分别表示Ai，Bi和Ci。

输出格式
输出T行，分别表示从城镇S到每个城市的最小花费，如果到不了的话输出NO PATH。
样例输入
6 3 3 4
1 2 5
3 4 5
5 6 10
3 5 -100
4 6 -100
1 3 -10
样例输出
NO PATH
NO PATH
5
0
-95
-100
数据规模与约定
对于20%的数据，T<=100，R<=500，P<=500；
对于30%的数据，R<=1000，R<=10000，P<=3000；
对于100%的数据，1<=T<=25000，1<=R<=50000，1<=P<=50000。

import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Scanner;

/**
 * @author 翔
 *
 */
public class Main {
    private static int max=10000000;
    private static int T;//城镇个数（也即顶点个数）
    private static int R;//道路个数（也即双向边个数）
    private static int P;//航路个数（也即单向便个数）
    private static int S;//配送中心（也即源点）
    private static int[] dist;记录从源点1到其它各顶点的路径长度数组
    private static Node[] node;//顶点数组
    private static ArrayDeque<Integer> queue=new ArrayDeque<Integer>(); 



    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        init();
        spfa();
        print();
    }

    private static void print(){
        for(int i=1;i<=T;i++){
            if(dist[i]<max){
                System.out.println(dist[i]);
            }else{
                System.out.println("NO PATH");
            }
        }
    }

    private static void init(){
        Scanner sc=new Scanner(System.in);
        T=sc.nextInt();
        R=sc.nextInt();
        P=sc.nextInt();
        S=sc.nextInt();
        dist=new int[T+1];
        node=new Node[T+1];

        for(int i=1;i<=T;i++){
            dist[i]=max;
            node[i]=new Node();
        }

        dist[S]=0;
        queue.add(S);

        for(int i=0;i<R;i++){
            int from=sc.nextInt();
            int to=sc.nextInt();
            int weight=sc.nextInt();

            node[from].list.add(to);
            node[from].weight.add(weight);

            node[to].list.add(from);
            node[to].weight.add(weight);
        }

        for(int i=0;i<P;i++){
            int from=sc.nextInt();
            int to=sc.nextInt();
            int weight=sc.nextInt();

            node[from].list.add(to);
            node[from].weight.add(weight);
        }
        sc.close();
    }

    //几乎所有的最短路算法其步骤都可以分为两步
    //1.初始化
    //2.松弛操作
    //
    //初始化： d数组全部赋值为INF（无穷大）；p数组全部赋值为s（即源点），或者赋值为-1，表示还没有知道前驱然后d[s]=0;
    //表示源点不用求最短路径，或者说最短路就是0。将源点入队；（另外记住在整个算法中有顶点入队了要记得标记vis数组，有顶点出队了记得消除那个标记）
    //
    //队列+松弛操作
    //读取队头顶点u，并将队头顶点u出队（记得消除标记）；将与点u相连的所有点v进行松弛操作，如果能更新估计值（即令d[v]变小），那么就更新，
    //另外，如果点v没有在队列中，那么要将点v入队（记得标记），如果已经在队列中了，那么就不用入队
    //以此循环，直到队空为止就完成了单源最短路的求解
    //
    //SPFA可以处理负权边
    //定理: 只要最短路径存在，上述SPFA算法必定能求出最小值。
    //证明：
    //每次将点放入队尾，都是经过松弛操作达到的。换言之，每次的优化将会有某个点v的最短路径估计值d[v]变小。
    //所以算法的执行会使d越来越小。由于我们假定图中不存在负权回路，所以每个结点都有最短路径值。
    //因此，算法不会无限执行下去，随着d值的逐渐变小，直到到达最短路径值时，算法结束，
    //这时的最短路径估计值就是对应结点的最短路径值。（证毕）
    //期望的时间复杂度O(ke)， 其中k为所有顶点进队的平均次数，可以证明k一般小于等于2。
    /**
     private static void spfa(){
        while(queue.size()!=0){
            //读取队头顶点u，并将队头顶点u出队（记得消除标记）；
            //将与点u相连的所有点v进行松弛操作，如果能更新估计值（即令d[v]变小），那么就更新，
            //另外，如果点v没有在队列中，那么要将点v入队（记得标记），如果已经在队列中了，那么就不用入队
            //以此循环，直到队空为止就完成了单源最短路的求解
            int queFir=queue.poll();
            for(int i=0;i<node[queFir].list.size();i++){
                int t=node[queFir].list.get(i);
                int weight=node[queFir].weight.get(i);
                if(dist[queFir]+weight<dist[t]){
                    dist[t]=dist[queFir]+weight;
                    path[t]=queFir;
                    if(!queue.contains(t)){
                        queue.offer(t);
                    }
                }
            }
        }
    }
     */
    private static void spfa(){
        while(queue.size()!=0){
            int queueFir=queue.poll();
            for(int i=0;i<node[queueFir].list.size();i++){
                int v=node[queueFir].list.get(i);
                int weight=node[queueFir].weight.get(i);
                if(dist[queueFir]+weight<dist[v]){
                    dist[v]=dist[queueFir]+weight;
                    if(!queue.contains(v)){
                        queue.offer(v);
                    }
                }
            }
        }
    }
}

class Node{
    ArrayList<Integer> list=new ArrayList<Integer>();
    ArrayList<Integer> weight=new ArrayList<Integer>();
}