从源点到其余各顶点的最短距离--迪杰斯特拉(Dijkstra)算法

问题描述：对于一个带权的有向图，如何求得从源点到其余各顶点的最短路径？
解决此问题的算法：迪杰斯特拉(Dijkstra)提出了一个按路径长度递增的次序产生最短路径的长度。
在此算法中引进了一个数组D[]，这个数组是用来存储，每个顶点当前的从源点到该顶点的最短路径长度。


思路决定出路，那么下面还是先理清楚思路。


算法具体步骤：
1． 初始化数组D[]。带权有向图是用邻接矩阵进行存储的。用邻接矩阵的第一行数据对D[]进行初始化。即D[]中存储的是，源点直接到其余各个顶点的距离。此时的S集中只有源点。
2． 从D[]中选出最小的那路径D[k]。将第k个顶点并入到S集中。
3． 根据这个D[k]修改属于V-S集中各顶点的D[i]值。若D[k]+arc[k][i]<D[i]则D[i] = D[k]+arc[k][i]。
4． 重复步骤2和3只到所有顶点都被归并到S集中。

 

具体算法实现：

 

[java] view plaincopy
 
  1. package graph;  
  2. /* 
  3.  * 其实用迪杰斯特拉算法寻找某一点到各个顶点的最短路径，主要包括三个步骤： 
  4.  * 1、从还未找到最短路径的顶点中选出拥有最短路径的顶点v，并将其标记为已找出最小路径 
  5.  * 2、由这个顶点v修改其它未标记为已找出最小路径的顶点的最短路径值。 
  6.  * 其中要用到一个辅助数组，其中存储每个顶点当前的最小路径值 
  7.  */  
  8. public class ShortestPath_DIJ   
  9. {  
  10.     Graph_AdjMatrix g_adjMatrix;  
  11.     boolean hasfound[];  
  12.     int D[];  
  13.     String[] path;  
  14.     int vetexNum;  
  15.     final int max = 10000;  
  16.       
  17.     public ShortestPath_DIJ(Graph_AdjMatrix g_adjMatrix)  
  18.     {  
  19.         this.g_adjMatrix = g_adjMatrix;  
  20.         vetexNum = g_adjMatrix.vertex.length;  
  21.         hasfound = new boolean[vetexNum];  
  22.         D = new int[vetexNum];  
  23.         path = new String[vetexNum];  
  24.         for(int i=0;i<vetexNum;i++)  
  25.         {  
  26.             hasfound[i] = false;  
  27.             D[i] = max;  
  28.             path[i] = new String("V0");  
  29.         }  
  30.     }  
  31.       
  32.     public void getShortPath(int start)  
  33.     {  
  34.         hasfound[start] = true;  
  35.         for(int t =0;t<vetexNum;t++)  
  36.         {  
  37.             D[t] = g_adjMatrix.adjMatrix[0][t];  
  38.         }  
  39.         for(int i=0;i<vetexNum;i++)  
  40.         {  
  41.             int min = max;  
  42.             int v =0;  
  43.             for(int j =0;j<vetexNum;j++)                                              //找出还未找到最段路径的顶点集中，路径最短的那个顶点。  
  44.             {  
  45.                 if(!hasfound[j]&& D[j]<min)  
  46.                 {  
  47.                     min = D[j];  
  48.                     v = j;  
  49.                 }  
  50.             }  
  51.             hasfound[v] = true;                                                       //将找到的最小路径顶点加入到以找到最短路径的顶点集中，即用true来标记该顶点的最短路径已经被找到  
  52.             if(v!=0&&path[v].endsWith("0"))                                           //当某个顶点v0直接可以到达，而且v0->v就是v0到v的最短路径  
  53.             {  
  54.                 path[v] = path[v]+","+g_adjMatrix.vertex[v];  
  55.             }  
  56.             for(int w =0;w<vetexNum;w++)                                              //修改其它还没有找到最小路径顶点的最小路径  
  57.             {  
  58.                 if(!hasfound[w]&&(D[v]+g_adjMatrix.adjMatrix[v][w]<D[w]))  
  59.                 {  
  60.                     D[w] = D[v]+g_adjMatrix.adjMatrix[v][w];  
  61.                     path[w] = path[v] +","+ g_adjMatrix.vertex[w];  
  62.                 }  
  63.                   
  64.             }  
  65.         }  
  66.                                                                                     //检测是否有未到达元素  
  67.         for(int i =0;i<vetexNum;i++)  
  68.         {  
  69.             if(!hasfound[i])  
  70.             {  
  71.                 path[i] = g_adjMatrix.vertex[i]+"无法到达！";  
  72.             }  
  73.         }  
  74.     }  
  75.       
  76.     public void printShortpath()  
  77.     {  
  78.         for(int i =0;i<vetexNum;i++)  
  79.         {  
  80.             System.out.println(path[i]);  
  81.         }  
  82.     }  
  83. }  

 转自 http://blog.csdn.net/pigli/article/details/5777491

posted @ 2014-06-13 02:09  princessd8251  阅读(1234)  评论(0)    收藏  举报