贪心算法-最短路径正式版（详解迪科斯彻Dijkstra算法）java语言

贪心算法-最短路径正式版（Dijkstra算法）java语言

算法设计：

Dijkstra算法是解决单源最短路径问题的贪心算法，它先求出长度最短的一条路径，再参照该最短路径求出长度次短的一条路径，直到求出从源点到其他各顶点的最短路径。
Dijkstra算法的基本思想是首先假定源点为u，顶点集合V被划分为两部分：集合V和V-S。初始时S中仅含有源点为u,其中S中的顶点到源点的最短路径已经确定。集合V-S 中包含的顶点到源点的最短路径待定，称从源点出发只经过S中的点到达V-S中的点的路径为特殊路径，并用数组dist[]记录当前每个顶点所对应的最短特殊路径长度。
Dijkstra算法采用的贪心策略是选择特殊路径长度最短的路径，将其连接的V-S中的顶点加入到集合S中，同时更新数组dist[].一旦S包含了所有的顶点，dist[]就是从源到所有其他顶点之间的最短路径长度。
（1）数据结构。设置地图的带权邻接矩阵为map[][],即如果从源点u到顶点i有边，就令map[][]等于<u,i>的权值，否则map[u][i]=无穷大;采用一维数组dist[i]来记录源点到i顶点的最短路径长度；采用一维数组p[i]来记录最短路径上i顶点的前驱。
（2）初始化。令集合S={u},对于集合V-S中的所有顶点x,初始化dist[i]=map[u][i],如果源点u到顶点i有边相连，初始化p[i]=u,否则p[i]=-1;
（3）找最小。在集合V-S中依照贪心策略来寻找使得dist[j]具有最小值的顶点t，即dist[t]=min(dist[j]|j属于V-S集合)，则顶点t就是集合V-S中距离源点u最近的顶点。
(4)加入S战队。将顶点t加入S中，同时更新V-S。
（5）判结束。如果集合V-S为空，算法结束，否则转（6）
（6）借东风。在（3）中已经找到了源点到t的最短路径，那么对集合V-S中所有与顶点t相邻的顶点j,都可以借助t走捷径。如果dist[j]>dist[t]+map[t][j],则dist[j]=dist[t]+map[t][j],记录顶点j的前驱为t，有p[j]=t,转（3）。
由此，可求得从源点u到图G的各个顶点的最短路径及长度，也可通过数组p[]逆向找到最短路径上经过的城市

代码：

import java.util.Scanner;
import java.util.Stack;

public class Main {
    static int INF=(int )1e7;//初始化为无穷大10000000
    static int map[][]=new int[100][100];//地图的带权邻接矩阵
    static int dist[]=new int[100];//最短距离数组
    static int p[]=new int[100];//前驱数组
    static int n,m;//n是城市的个数，m为城市间的路线
    static boolean flag[]=new boolean[100];//如果flag[i]=true;说明顶点i已经加入到集合S中；否则顶点i属于集合V-S;
    static void Dijkstra(int u){
        for (int i=1;i<=n;i++){
            dist[i]=map[u][i];//初始化源点u到各个顶点之间的最短路径长度
            flag[i]=false;
            if(dist[i]==INF)
                p[i]=-1;//源点u到该顶点的路径长度为无穷大，说明顶点i与源点u不相邻
            else
                p[i]=u;//说明顶点i与源点不相邻,设置顶点i的前驱p[i]为u;
        }
        dist[u]=0;
        flag[u]=true;//初始化时 ，集合S中只有一个元素:源点u;
        for(int i=1;i<=n;i++){
            int temp=INF,t=u;
            for(int j=1;j<=n;j++)//在集合V-S中寻找距离源点u最近的顶点t
            if(!flag[j]&&dist[j]<temp){
                t=j;//记录距离源点u最近的顶点
                temp=dist[j];
            }
            if(t==u) return ;//找不到t,跳出循环
            flag[t]=true;//否则，将t加入集合
            for(int j=1;j<=n;j++)//更新集合V-S中与t邻接的顶点到源点u的距离
                if(!flag[j]&&map[t][j]<INF)//!flag[j]表示j在V-S中，map[t][j]<INF表示t与j邻接
                if(dist[j]>(dist[t]+map[t][j]))//经过t到达j的最短路径
                {
                    dist[j]=dist[t]+map[t][j];
                    p[j]=t;//记录j的前驱为t
                }
        }
    }
    static void findPath(int u){
        int x=0;
        Stack stack=new Stack();
        for(int i=1;i<=n;i++){
            x=p[i];
            while (x!=-1){
                stack.push(x);//将前驱压入栈中
                x=p[x];
            }
            System.out.print("源点"+u+"到顶点" +i+"最短路径为：");
            while(!stack.empty()){
                System.out.print(stack.peek()+"--");
                stack.pop();
            }
            System.out.println(i);
            System.out.println("最短路径的数值为："+dist[i]);
        }
    }
    public static void main(String args[]){
        Scanner sc=new Scanner(System.in);
        int u,v,w,st;
        System.out.println("请输入城市的个数: ");
        n=sc.nextInt();
        System.out.println("请输入城市之间的路线的个数: ");
        m=sc.nextInt();
        System.out.println("请输入城市之间的路线以及距离: ");
        for(int i=1;i<=n;i++)
            for(int j=1;j<=n;j++)
            {
                map[i][j]=INF;
            }
        while (m-->0){
            u=sc.nextInt();
            v=sc.nextInt();
            w=sc.nextInt();
            map[u][v]=Math.min(map[u][v],w);
        }
        System.out.println("请输入现在所处的位置: ");
        st=sc.nextInt();
        Dijkstra(st);
        System.out.println("要去的位置: ");
        int end=sc.nextInt();
        if(end>n){
            System.out.println("该位置没有在地图中!");
        }
        else{
        if(dist[end]==INF)
            System.out.println("无路可达!");
        else{
            System.out.println("最短距离为： "+dist[end]);
        }
           findPath(st);
    }
}}

运行示例：

欢迎留言交流！