Expm 4_2 有向无环图中的最短路径问题

【问题描述】

建立一个从源点S到终点E的有向无环图，设计一个动态规划算法求出从S到E的最短路径值，并输出相应的最短路径。

解：

 package org.xiu68.exp.exp4;

 import java.util.ArrayDeque;
 import java.util.Stack;

 public class Exp4_2 {
     //建立一个从源点S到终点E的有向无环图，设计一个动态规划算法求出从S到E的最短路径值，并输出相应的最短路径。
     public static void main(String[] args) {
         int m=Integer.MAX_VALUE;
         int[][] edges=new int[][]{
             {m,1,m,2,m,m},
             {m,m,6,m,m,m},
             {m,m,m,m,1,2},
             {m,4,m,m,3,m},
             {m,m,m,m,m,1},
             {m,m,m,m,m,m}
         };
         MGraph1 m1=new MGraph1(edges);
         m1.minPath(0, 5);
         //输出
         //  0 to 5 is 6
         // the path is:0-->3-->4-->5

     }
 }

 class MGraph1{
     private int[][] edges;        //有向无环图
     private int    vexNum;            //顶点数量

     public MGraph1(int[][] edges){
         this.edges=edges;
         this.vexNum=edges.length;
     }

     public void minPath(int start,int end){

         int[] dist=new int[vexNum];            //源点到该点的最短路径
         for(int i=0;i<vexNum;i++)
             dist[i]=Integer.MAX_VALUE;
         dist[start]=0;

         int[] pre=new int[vexNum];            //最短路径中该点的前一个顶点
         pre[start]=-1;

         Stack<Integer> queue=new Stack<>();    //存放拓扑排序序列
         topoSort(queue);

         while(!queue.isEmpty()){
             int j=queue.pop();

             for(int i=0;i<vexNum;i++){
                 if(edges[i][j]!=Integer.MAX_VALUE && dist[j]>dist[i]+edges[i][j]){
                     dist[j]=dist[i]+edges[i][j];
                     pre[j]=i;
                 }
             }//for
         }//while

         //打印最短路径
         System.out.println(start+" to "+end+" is "+dist[end]);

         String path=""+end;
         int preVex=pre[end];

         while(preVex!=-1){
             path=preVex+"-->"+path;
             preVex=pre[preVex];
         }
         System.out.println("the path is:"+path);

     }

     //拓扑排序
     public void topoSort(Stack<Integer> queue){
         boolean[] visited=new boolean[vexNum];
         for(int i=0;i<vexNum;i++){
             if(!visited[i])
                 dfs(queue,i,visited);
         }
     }

     //利用深度优先搜索进行拓扑排序
     public void dfs(Stack<Integer> queue,int v,boolean[] visited){
         visited[v]=true;
         for(int i=0;i<vexNum;i++){
             if(edges[v][i]!=Integer.MAX_VALUE && !visited[i])
                 dfs(queue,i,visited);
         }
         queue.push(v);
     }
 }