二十、单源最短路径（迪杰斯特拉算法）
迪杰斯特拉算法介绍
单源最短路径：源结点s到其它每个结点v的最短路径。
最短路径不一定是唯一的，最短路径树也不一定是唯一的。
普利姆算法与迪杰斯特拉算法区别：普利姆算法中的lowcost[]记录剩下顶点到最小生成树的最短距离。迪杰斯特拉算法中的dist[]记录剩下顶点到源顶点s的最短距离
迪杰斯特拉(Dijkstra)算法是典型最短路径算法，用于计算一个节点到其他节点的最短路径，该算法要求所有边的权重都为非负值。
它的主要特点是以起始点为中心向外层层扩展(广度优先搜索思想)，直到扩展到终点为止。
基本思想
通过Dijkstra计算图G中的最短路径时，需要指定起点s(即从顶点s开始计算)。
此外，引进两个集合S和U。S的作用是记录已求出最短路径的顶点(以及相应的最短路径长度)，而U则是记录还未求出最短路径的顶点(以及该顶点到起点s的距离)。
初始时，S中只有起点s；U中是除s之外的顶点，并且U中顶点的路径是"起点s到该顶点的路径"。然后，从U中找出路径最短的顶点，并将其加入到S中；接着，更新U中的顶点和顶点对应的路径。 然后，再从U中找出路径最短的顶点，并将其加入到S中；接着，更新U中的顶点和顶点对应的路径。 ... 重复该操作，直到遍历完所有顶点。
操作步骤
(1) 初始时，S只包含起点s；U包含除s外的其他顶点，且U中顶点的距离为"起点s到该顶点的距离"[例如，U中顶点v的距离为(s,v)的长度，然后s和v不相邻，则v的距离为∞]。
(2) 从U中选出"距离最短的顶点k"，并将顶点k加入到S中；同时，从U中移除顶点k。
(3) 更新U中各个顶点到起点s的距离。之所以更新U中顶点的距离，是由于上一步中确定了k是求出最短路径的顶点，从而可以利用k来更新其它顶点的距离；例如，(s,v)的距离可能大于(s,k)+(k,v)的距离。
(4) 重复步骤(2)和(3)，直到遍历完所有顶点。
单纯的看上面的理论可能比较难以理解，下面通过实例来对该算法进行说明。
迪杰斯特拉算法图解
以上图G4为例，来对迪杰斯特拉进行算法演示(以第4个顶点D为起点)。错误：B（23）-->B(13)
初始状态：S是已计算出最短路径的顶点集合，U是未计算除最短路径的顶点的集合！
第1步：将顶点D加入到S中。
此时，S={D(0)}, U={A(∞),B(∞),C(3),E(4),F(∞),G(∞)}。 注:C(3)表示C到起点D的距离是3。
第2步：将顶点C加入到S中。
上一步操作之后，U中顶点C到起点D的距离最短；因此，将C加入到S中，同时更新U中顶点的距离。以顶点F为例，之前F到D的距离为∞；但是将C加入到S之后，F到D的距离为9=(F,C)+(C,D)。
此时，S={D(0),C(3)}, U={A(∞),B(23),E(4),F(9),G(∞)}。
第3步：将顶点E加入到S中。
上一步操作之后，U中顶点E到起点D的距离最短；因此，将E加入到S中，同时更新U中顶点的距离。还是以顶点F为例，之前F到D的距离为9；但是将E加入到S之后，F到D的距离为6=(F,E)+(E,D)。
此时，S={D(0),C(3),E(4)}, U={A(∞),B(23),F(6),G(12)}。
第4步：将顶点F加入到S中。
此时，S={D(0),C(3),E(4),F(6)}, U={A(22),B(13),G(12)}。
第5步：将顶点G加入到S中。
此时，S={D(0),C(3),E(4),F(6),G(12)}, U={A(22),B(13)}。
第6步：将顶点B加入到S中。
此时，S={D(0),C(3),E(4),F(6),G(12),B(13)}, U={A(22)}。
第7步：将顶点A加入到S中。
此时，S={D(0),C(3),E(4),F(6),G(12),B(13),A(22)}。
此时，起点D到各个顶点的最短距离就计算出来了：A(22) B(13) C(3) D(0) E(4) F(6) G(12)。
邻接矩阵：
class Vertex
{
public char label;
public boolean wasVisited;
public Vertex(char lab)
{
label = lab;
wasVisited = false;
}
}
class UDGraph
{
private final int MAX_VERTS = 20;
private Vertex vertexList[];
private int adjMat[][];
private int nVerts;
public UDGraph()
{
vertexList = new Vertex[MAX_VERTS];
adjMat = new int[MAX_VERTS][MAX_VERTS];
nVerts = 0;
for(int i=0;i<MAX_VERTS;i++)
for(int j=0;j<MAX_VERTS;j++)
adjMat[i][j] = Integer.MAX_VALUE;
}
public void addVertex(char lab)
{
vertexList[nVerts++] = new Vertex(lab);
}
public void addEdge(int start,int end,int weight)
{
adjMat[start][end] = weight;
adjMat[end][start] = weight;
}
public void dijkstra(int v)
{
int k=0;
//dist[vi]表示当前已找到的从顶点v到每个终点vi的最短路径的长度
int dist[] = new int[MAX_VERTS];
//prev[vi]表示从v到vi最短路径上vi的前一个顶点
int prev[] = new int[MAX_VERTS];
//其它顶点初始化
for(int i=0;i<nVerts;i++)
{
dist[i] = adjMat[v][i];
prev[i]=v;
}
//顶点v初始化
prev[v] = -1;
vertexList[v].wasVisited = true;
//选中某个顶点后（这里是v）,每次选取剩下顶点中的一个，一共要有nVerts-1个次
for(int i=0;i<nVerts-1;i++)
{
int min = Integer.MAX_VALUE;
//选出v到剩下顶点的最短路径长度
for(int j=0;j<nVerts;j++)
{
if(!vertexList[j].wasVisited && dist[j]<min)
{
min = dist[j];
k=j;
}
}
vertexList[k].wasVisited = true;
// 修正当前最短路径和前驱顶点
// 即，当已经"顶点k的最短路径"之后，更新"未获取最短路径的顶点的最短路径和前驱顶点"。
for(int m=0;m<nVerts;m++)
{
//m与k是连接的且m未被访问过的且m与k之间的距离k与v到k最短路径长度之和小于修正前v到m的最短路径长度
if(adjMat[k][m]!= Integer.MAX_VALUE && !vertexList[m].wasVisited && min+adjMat[k][m]<dist[m])
{
dist[m] = min+adjMat[k][m];
prev[m] = k;
}
}
}
// 打印dijkstra最短路径的结果
System.out.println("源顶点："+vertexList[v].label);
for (int i=0; i < nVerts; i++)
{
if(i!=v)
{
int j = prev[i];
System.out.print(vertexList[i].label);
while(j !=-1)
{
System.out.print(vertexList[j].label);
j=prev[j];
}
System.out.println(" 顶点"+vertexList[v].label+"到"+vertexList[i].label+"的最短距离："+dist[i]);
}
}
}
}
public class MatrixUDG_Dijkstra
{
public static void main(String[] args)
{
UDGraph theGraph = new UDGraph();
theGraph.addVertex('A'); // 0
theGraph.addVertex('B'); // 1
theGraph.addVertex('C'); // 2
theGraph.addVertex('D'); // 3
theGraph.addVertex('E'); // 4
theGraph.addVertex('F'); // 5
theGraph.addVertex('G'); // 6
theGraph.addEdge(0, 1,4); // AB
theGraph.addEdge(0, 2,6); // AC
theGraph.addEdge(0, 3,6); // AD
theGraph.addEdge(1, 2,1); // BC
theGraph.addEdge(1, 4,7); // BE
theGraph.addEdge(2, 4,6); // CE
theGraph.addEdge(2, 5,4); // CF
theGraph.addEdge(3, 2,2); // DC
theGraph.addEdge(3, 5,5); // DF
theGraph.addEdge(4, 6,6); // EG
theGraph.addEdge(5,4,1); // FE
theGraph.addEdge(5,6,8); // FG
//源顶点B
theGraph.dijkstra(1);
}
}
结果：
源顶点：B
AB 顶点B到A的最短距离：4
CB 顶点B到C的最短距离：1
DCB 顶点B到D的最短距离：3
EFCB 顶点B到E的最短距离：6
FCB 顶点B到F的最短距离：5
GEFCB 顶点B到G的最短距离：12
邻接链表：
class Vertex
{
public char label;
public boolean wasVisited;
public Edge firstEdge;
public Vertex(char lab)
{
this.label = lab;
this.wasVisited = false;
firstEdge = null;
}
}
class Edge
{
public int dest;
public int weight;
public Edge nextEdge;
public Edge(int dest,int weight)
{
this.dest= dest;
this.weight = weight;
nextEdge = null;
}
}
class UDGraph{
private final int MAX_VERTS = 20;//图的最大顶点数
private int nVerts = 0;//当前顶点数
private Vertex vertexList[];//顶点链表
public UDGraph()
{
vertexList = new Vertex[MAX_VERTS];
}
public void addVertex(char lab)
{
vertexList[nVerts++] = new Vertex(lab);
}
public void addEdge(int start,int end,int weight)
{
Edge startEdge = new Edge(start,weight);
Edge endEdge = new Edge(end,weight);
Edge edge2 = vertexList[start].firstEdge;
if(edge2==null)
{
vertexList[start].firstEdge = endEdge;
}else
{
while(edge2.nextEdge!=null)
edge2 = edge2.nextEdge;
edge2.nextEdge = endEdge;
}
Edge edge3 = vertexList[end].firstEdge;
if(edge3==null)
{
vertexList[end].firstEdge = startEdge;
}else
{
while(edge3.nextEdge!=null)
edge3 = edge3.nextEdge;
edge3.nextEdge = startEdge;
}
}
public void dijkstra(int v)
{
int k=0;
//dist[vi]表示当前已找到的从顶点v到每个终点vi的最短路径的长度
int dist[] = new int[MAX_VERTS];
//prev[vi]表示从v到vi最短路径上vi的前一个顶点
int prev[] = new int[MAX_VERTS];
//其它顶点初始化
for(int i=0;i<nVerts;i++)
{
dist[i] = getWeight(v, i);
prev[i]=v;
}
//顶点v初始化
prev[v] = -1;
vertexList[v].wasVisited = true;
//选中某个顶点后（这里是v）,每次选取剩下顶点中的一个，一共要有nVerts-1个次
for(int i=0;i<nVerts-1;i++)
{
int min = Integer.MAX_VALUE;
//选出v到剩下顶点的最短路径长度
for(int j=0;j<nVerts;j++)
{
if(!vertexList[j].wasVisited && dist[j]<min)
{
min = dist[j];
k=j;
}
}
vertexList[k].wasVisited = true;
// 修正当前最短路径和前驱顶点
// 即，当已经"顶点k的最短路径"之后，更新"未获取最短路径的顶点的最短路径和前驱顶点"。
for(int m=0;m<nVerts;m++)
{
//m与k是连接的且m未被访问过的且m与k之间的距离k与v到k最短路径长度之和小于修正前v到m的最短路径长度
if(getWeight(k, m)!=Integer.MAX_VALUE&&!vertexList[m].wasVisited&&min+getWeight(k, m)<dist[m])
{
dist[m] = min+getWeight(k, m);
prev[m] = k;
}
}
}
// 打印dijkstra最短路径的结果
System.out.println("源顶点："+vertexList[v].label);
for (int i=0; i < nVerts; i++)
{
if(i!=v)
{
int j = prev[i];
System.out.print(vertexList[i].label);
while(j !=-1)
{
System.out.print(vertexList[j].label);
j=prev[j];
}
System.out.println(" 顶点"+vertexList[v].label+"到"+vertexList[i].label+"的最短距离："+dist[i]);
}
}
}
/*
* 获取边<start, end>的权值；若start和end不是连通的，则返回无穷大。
*/
private int getWeight(int start, int end)
{
if (start==end)
return 0;
Edge currentEdge = vertexList[start].firstEdge;
while (currentEdge != null)
{
if (end==currentEdge.dest)
return currentEdge.weight;
currentEdge = currentEdge.nextEdge;
}
return Integer.MAX_VALUE;
}
}
public class ListUDG_Dijkstra
{
public static void main(String[] args)
{
UDGraph theGraph = new UDGraph();
theGraph.addVertex('A');// 0
theGraph.addVertex('B');// 1
theGraph.addVertex('C');// 2
theGraph.addVertex('D');// 3
theGraph.addVertex('E');// 4
theGraph.addVertex('F');// 5
theGraph.addVertex('G');// 6
theGraph.addEdge(0, 1,4); // AB
theGraph.addEdge(0, 2,6); // AC
theGraph.addEdge(0, 3,6); // AD
theGraph.addEdge(1, 2,1); // BC
theGraph.addEdge(1, 4,7); // BE
theGraph.addEdge(2, 4,6); // CE
theGraph.addEdge(2, 5,4); // CF
theGraph.addEdge(3, 2,2); // DC
theGraph.addEdge(3, 5,5); // DF
theGraph.addEdge(4, 6,6); // EG
theGraph.addEdge(5, 4,1); // FE
theGraph.addEdge(5, 6,8); // FG
//源顶点G
theGraph.dijkstra(6);
}
}
结果：
源顶点：G
ABCFEG 顶点G到A的最短距离：16
BCFEG 顶点G到B的最短距离：12
CFEG 顶点G到C的最短距离：11
DFEG 顶点G到D的最短距离：12
EG 顶点G到E的最短距离：6
FEG 顶点G到F的最短距离：7
