蓝桥杯_算法训练_节点选择（用Dijkstra,Bellman-Ford,SPFA算法分别实现）

问题描述
给定一个n个顶点，m条边的有向图（其中某些边权可能为负，但保证没有负环）。
请你计算从1号点到其他点的最短路（顶点从1到n编号）。

输入格式
第一行两个整数n, m。
接下来的m行，每行有三个整数u, v, l，表示u到v有一条长度为l的边。

输出格式
共n-1行，第i行表示1号点到i+1号点的最短路。
样例输入
3 3
1 2 -1
2 3 -1
3 1 2
样例输出
-1
-2
数据规模与约定
对于10%的数据，n = 2，m = 2。
对于30%的数据，n <= 5，m <= 10。
对于100%的数据，1 <= n <= 20000，1 <= m <= 200000，-10000 <= l <= 10000，保证从任意顶点都能到达其他所有顶点。

Dijkstra算法解决单源点最短路径问题：

import java.util.ArrayList;
import java.util.Scanner;
/** * @author 翔 * */
public class Main {
// Dijkstra算法的思想
// 将图G中所有的顶点V分成两个顶点集合S和T。
// 以v为源点已经确定了最短路径的终点并入S集合中，S初始时只含顶点v,T则是尚未确定到源点v最短路径的顶点集合。
// 然后每次从T集合中选择S集合点中到T路径最短的那个点，并加入到集合S中，并把这个点从集合T删除。直到T集合为空为止。 


// Dijkstra算法的具体步骤
// 1、选一顶点v为源点，并视从源点v出发的所有边为到各顶点的最短路径
// （确定数据结构：因为求的是最短路径，所以①就要用一个记录从源点v到其它各顶点的路径长度数组dist[],
// 开始时，dist是源点v到顶点i的直接边长度，即dist中记录的是邻接阵的第v行。
// ②设一个用来记录从源点到其它顶点的路径数组path[],path中存放路径上第i个顶点的前驱顶点）。
// 2、在上述的最短路径dist[]中选一条最短的，并将其终点（即<v,k>）k加入到集合s中。
// 3、调整T中各顶点到源点v的最短路径。 因为当顶点k加入到集合s中后，
// 源点v到T中剩余的其它顶点j就又增加了经过顶点k到达j的路径,这条路径可能要比源点v到j原来的最短的还要短。
// 调整方法是比较dist[k]+g[k,j]与dist[j]，取其中的较小者。
// 4、再选出一个到源点v路径长度最小的顶点k,从T中删去后加入S中，再回去到第三步，如此重复，直到集合S中的包含图G的所有顶点。


    private static int n;//顶点总个数
    private static int[] dist;//记录从源点1到其它各顶点的路径长度数组
    private static int[] path;//记录从源点1到其它顶点的路径数组path[],path[i]中存放路径上第i个顶点的前驱顶点
    private static int[][] g;//g[k][j]表示顶点k到顶点j的路径长度,即所谓的边权，且g[k][j]！=g[j][k]
    private static ArrayList<Integer> S=new ArrayList<Integer>();//已经确定了最短路径的顶点的集合
    private static ArrayList<Integer> V=new ArrayList<Integer>();//尚未确定最短路径的顶点集合

    /** * @param args */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        init();
        dijkstra();
        print();
    }
    //初始化各参数、数组
    private static void init(){
        Scanner sc=new Scanner(System.in);
        n=sc.nextInt();
        dist=new int[n+1];
        path=new int[n+1];
        g=new int[n+1][n+1];
        int m=sc.nextInt();//m为边的总条数

        //初始化假设各顶点与顶点间不存在边
        for(int i=1;i<=n;i++){
            for(int j=1;j<=n;j++){
                if(i!=j){
                   g[i][j]=Integer.MAX_VALUE;
                }
            }
        }
        //初始化g矩阵
        for(int i=0;i<m;i++){
            int s=sc.nextInt();
            int t=sc.nextInt();
            int weight=sc.nextInt();
            g[s][t]=weight;//获取边值
        }
        //初始化dist数组
        for(int i=2;i<=n;i++){
            if(g[1][i]!=Integer.MAX_VALUE){//当顶点i和顶点1有边时
                dist[i]=g[1][i];
                path[i]=1;
            }else{////当顶点i和顶点1无边时
                dist[i]=Integer.MAX_VALUE;
            }
        }
        //初始化V数组
        for(int i=2;i<=n;i++){
            V.add(i);
        }
        sc.close();//关闭字符扫描器
    }

    private static void dijkstra(){
        int k=findDistMin();//在上述的最短路径dist[]中选一条最短的，并将其终点（即<1,k>）k加入到集合s中。
        path[k]=1;
        S.add(k);

        while(V.size()!=0){
            //源点1到V中剩余的其它顶点j就又增加了经过顶点k到达j的路径,这条路径可能要比源点1到j原来的最短的还要短。
            //调整方法是比较dist[k]+g[k,j]与dist[j]，取其中的较小者。
            for(int i=0;i<V.size();i++){
                int j=V.get(i);
                if(g[k][j]!=Integer.MAX_VALUE){
                    if(dist[k]+g[k][j]<dist[j]){
                        dist[j]=dist[k]+g[k][j];
                        path[j]=k;
                    }
                }
            }
            k=findDistMin();    
            V.remove(new Integer(k));
            S.add(k);
        }
    }

    //打印最短路径(本程序的输出和题目要求的输出不同)
    private static void print(){
        for(int i=2;i<=n;i++){
            System.out.println("顶点"+i+"到顶点"+1+"的最短路径："+dist[i]);
            System.out.print("依次经过的顶点为："+i);
            int pre=i;
            while(path[pre]!=1){
                System.out.print(" "+path[pre]);
                pre=path[pre];
            }
            System.out.print(" 1\n\n");
        }
    }

    //选出一个到源点v路径长度最小的顶点k
    private static int findDistMin(){
        int minIndex=-1;
        int min=Integer.MAX_VALUE;
        for(int i=0;i<V.size();i++){
            int j=V.get(i);
            if(dist[j]<min){
                minIndex=j;
                min=dist[j];
            }
        }
        return minIndex;
    }
}

Bellman-Ford算法解决单源点最短路径问题

import java.util.Scanner;

/** * Bellman-Ford的解题思想 数组Distant[i]记录从源点s到顶点i的路径长度，初始化数组Distant[n]为, Distant[s]为0； 以下操作循环执行至多n-1次，n为顶点数： 对于每一条边e(u, v)，如果Distant[u] + w(u, v) < Distant[v]，则另Distant[v] = Distant[u]+w(u, v)。w(u, v)为边e(u,v)的权值； 若上述操作没有对Distant进行更新，说明最短路径已经查找完毕，或者部分点不可达，跳出循环。否则执行下次循环； 为了检测图中是否存在负环路，即权值之和小于0的环路。 对于每一条边e(u, v)，如果存在Distant[u] + w(u, v) < Distant[v]的边，则图中存在负环路，即是说该图无法求出单源最短路径。 否则数组Distant[n]中记录的就是源点s到各顶点的最短路径长度。 Bellman－Ford算法可以大致分为三个部分: 第一，初始化所有点。每一个点保存一个值，表示从原点到达这个点的距离，将原点的值设为0，其它的点的值设为无穷大（表示不可达）。 第二，进行循环，循环下标为从1到n－1（n等于图中点的个数）。在循环内部，遍历所有的边，进行松弛计算。 第三，遍历途中所有的边（edge（u，v）），判断是否存在这样情况： d（v） > d (u) + w(u,v)则返回false，表示途中存在从源点可达的权为负的回路。 之所以需要第三部分的原因，是因为，如果存在从源点可达的权为负的回路。则应为无法收敛而导致不能求出最短路径。 * @author 翔 * */
public class Main {
    private static int max=1000000;
    private static int nodeNum;//顶点个数
    private static int edgeNum;//边条数
    private static int[] dist;//记录从源点s到顶点i的路径长度
    private static Edge[] edge;//边集
    private static int[] path;////记录从源点1到其它顶点的路径数组path[],path[i]中存放路径上第i个顶点的前驱顶点
    /** * @param args */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        init();
        if(bellman_Ford()){
            System.out.println("存在负权环，不能求出最短路径！");
        }else{
            for(int i=2;i<=nodeNum;i++){
                System.out.println(dist[i]);
            }
            //print();
        }
    }

    private static void init(){
        Scanner sc=new Scanner(System.in);
        nodeNum=sc.nextInt();
        edgeNum=sc.nextInt();
        dist=new int[nodeNum+1];
        path=new int[nodeNum+1];
        edge=new Edge[edgeNum];

        for(int i=0;i<edgeNum;i++){
               int u=sc.nextInt();
               int v=sc.nextInt();
               int weight=sc.nextInt(); 
               edge[i]=new Edge(u,v,weight);
        }

        //初始化所有点。每一个点保存一个值，表示从原点到达这个点的距离，将原点的值设为0，其它的点的值设为无穷大（表示不可达）。
        dist[1]=0;
        for(int i=2;i<=nodeNum;i++){
            dist[i]=max;
        }
        sc.close();
    }

    private static boolean bellman_Ford() {
        //进行循环，循环下标为从1到n－1（n等于图中点的个数）。在循环内部，遍历所有的边，进行松弛计算。
        for (int i = 1; i < nodeNum; i++) {
            int count=0;
            for (int j = 0; j < edgeNum; j++) {
                int u=edge[j].u;
                int v=edge[j].v;
                int weight=edge[j].weight;
                if(dist[u]+weight<dist[v]){
                    dist[v]=dist[u]+weight;
                    path[v]=u;
                    count++;
                }
            }
            if(count==0){
                break;
            }
        }

        boolean hasNegativeCycle=false;//是否存在负权环
        //遍历途中所有的边（edge（u，v）），判断是否存在这样情况：
        //d（v） > d(u)+ w(u,v)则返回false，表示途中存在从源点可达的权为负的回路。
        for(int i=0;i<edgeNum;i++){
            int u=edge[i].u;
            int v=edge[i].v;
            int weight=edge[i].weight;
            if(dist[u]+weight<dist[v]){
                hasNegativeCycle=true;
                break;
            }
        }
        return hasNegativeCycle;
    }

    private static void print(){
        for(int i=2;i<=nodeNum;i++){
            System.out.println("顶点"+i+"到顶点"+1+"的最短路径："+dist[i]);
            System.out.print("依次经过的顶点为："+i);
            int pre=i;
            while(path[pre]!=1){
                System.out.print(" "+path[pre]);
                pre=path[pre];
            }
            System.out.print(" 1\n\n");
        }
    }
}
class Edge{
    int u;//边起点
    int v;//边终点
    int weight;//边权重，可以为负数
    public Edge(int u,int v,int weight){
        this.u=u;
        this.v=v;
        this.weight=weight;
    }
}

SPFA算法解决单源点最短路径问题

import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Scanner;
//几乎所有的最短路算法其步骤都可以分为两步
//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。
public class Main {
    private static int max=10000000;
    private static int nodeNum;
    private static int edgeNum;
    private static int[] dist;
    private static Node[] node;
    private static ArrayDeque<Integer> queue=new ArrayDeque<Integer>();
    private static int[] path;

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

    private static void init(){
        Scanner sc=new Scanner(System.in);
        nodeNum=sc.nextInt();
        edgeNum=sc.nextInt();
        dist=new int[nodeNum+1];
        path=new int[nodeNum+1];
        node=new Node[nodeNum+1];
        for(int i=1;i<=nodeNum;i++){
            dist[i]=max;
            node[i]=new Node();

        }
        dist[1]=0;
        queue.offer(1);

        for(int i=0;i<edgeNum;i++){
            int s=sc.nextInt();
            int t=sc.nextInt();
            int weight=sc.nextInt();
            node[s].list.add(t);
            node[s].weight.add(weight);
        }
    }

    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 print(){
        for(int i=2;i<=nodeNum;i++){
            System.out.println("顶点"+i+"到顶点"+1+"的最短路径："+dist[i]);
            System.out.print("依次经过的顶点为："+i);
            int pre=i;
            while(path[pre]!=1){
                System.out.print(" "+path[pre]);
                pre=path[pre];
            }
            System.out.print(" 1\n\n");
        }
    }
}

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