最短路径
1.定义
用于计算一个节点到其他所有节点的最短路径。主要特点是以起始点为中心向外层层扩展,直到扩展到终点为止。
无权图的单源最短路径
有权图的单源最短路径
给一篇很棒的参考博客,大话解析版的:https://www.cnblogs.com/Braveliu/p/3458671.html
给定带权有向图G和源点v,求从v到G中其余各顶点的最短路径。
我们用一个例子来具体说明迪杰斯特拉算法的流程。
定义源点为 0,dist[i]
为源点 0 到顶点 i 的最短路径。其过程描述如下:
步骤 | dist[1] | dist[2] | dist[3] | dist[4] | 已找到的集合 |
---|---|---|---|---|---|
第 1 步 | 8 | 1 | 2 | +∞ | {2} |
第 2 步 | 8 | × | 2 | 4 | {2, 3} |
第 3 步 | 5 | × | × | 4 | {2, 3, 4} |
第 4 步 | 5 | × | × | × | {2, 3, 4, 1} |
第 5 步 | × | × | × | × | {2, 3, 4, 1} |
第 1 步:从源点 0 开始,找到与其邻接的点:1,2,3,更新dist[]
数组,因 0 不与 4 邻接,故dist[4]
为正无穷。在dist[]
中找到最小值,其顶点为 2,即此时已找到 0 到 2 的最短路。
第 2 步:从 2 开始,继续更新dist[]
数组:2 与 1 不邻接,不更新;2 与 3 邻接,因0→2→3
比dist[3]
大,故不更新dist[3]
;2 与 4 邻接,因0→2→4
比dist[4]
小,故更新dist[4]
为 4。在dist[]
中找到最小值,其顶点为 3,即此时又找到 0 到 3 的最短路。
第 3 步:从 3 开始,继续更新dist[]
数组:3 与 1 邻接,因0→3→1
比dist[1]
小,更新dist[1]
为 5;3 与 4 邻接,因0→3→4
比dist[4]
大,故不更新。在dist[]
中找到最小值,其顶点为 4,即此时又找到 0 到 4 的最短路。
第 4 步:从 4 开始,继续更新dist[]
数组:4 与 1 不邻接,不更新。在dist[]
中找到最小值,其顶点为 1,即此时又找到 0 到 1 的最短路。
第 5 步:所有点都已找到,停止。
对于上述步骤,你可能存在以下的疑问:
若 A 作为源点,与其邻接的只有 B,C,D 三点,其dist[]
最小时顶点为 C,即就可以确定A→C
为 A 到 C 的最短路。但是我们存在疑问的是:是否还存在另一条路径使 A 到 C 的距离更小? 用反证法证明。
假设存在如上图的红色虚线路径,使A→D→C
的距离更小,那么A→D
作为A→D→C
的子路径,其距离也比A→C
小,这与前面所述 “dist[]
最小时顶点为 C” 矛盾,故假设不成立。因此这个疑问不存在。
根据上面的证明,我们可以推断出,Dijkstra 每次循环都可以确定一个顶点的最短路径,故程序需要循环 n-1 次。
算法实现:
/* 邻接表存储 - 无权图的单源最短路算法 */
/* dist[]和path[]全部初始化为-1 */
void Unweighted ( LGraph Graph, int dist[], int path[], Vertex S )
{
Queue Q;
Vertex V;
PtrToAdjVNode W;
Q = CreateQueue( Graph->Nv ); /* 创建空队列, MaxSize为外部定义的常数 */
dist[S] = 0; /* 初始化源点 */
AddQ (Q, S);
while( !IsEmpty(Q) ){
V = DeleteQ(Q);
for ( W=Graph->G[V].FirstEdge; W; W=W->Next ) /* 对V的每个邻接点W->AdjV */
if ( dist[W->AdjV]==-1 ) { /* 若W->AdjV未被访问过 */
dist[W->AdjV] = dist[V]+1; /* W->AdjV到S的距离更新 */
path[W->AdjV] = V; /* 将V记录在S到W->AdjV的路径上 */
AddQ(Q, W->AdjV);
}
} /* while结束*/
}
Dijkstra 算法
其中
增加一个 v进入 S,可能影响另外一个 w 的dist值!
这句话怎么理解呢
实际上,如果收录v使得s到w的路径变短
则s到w的路径一定经过v(v一定在路径上),并且v到w有一条边
换句话说,w一定是v的邻接点
即把v加进去,它只能影响他的一圈邻接点
算法伪码
这个算法的时间复杂度主要取决于如何寻找未收录顶点中dist最小者
算法实现:
/* 邻接矩阵存储 - 有权图的单源最短路算法 */
Vertex FindMinDist( MGraph Graph, int dist[], int collected[] )
{ /* 返回未被收录顶点中dist最小者 */
Vertex MinV, V;
int MinDist = INFINITY;
for (V=0; V<Graph->Nv; V++) {
if ( collected[V]==false && dist[V]<MinDist) {
/* 若V未被收录,且dist[V]更小 */
MinDist = dist[V]; /* 更新最小距离 */
MinV = V; /* 更新对应顶点 */
}
}
if (MinDist < INFINITY) /* 若找到最小dist */
return MinV; /* 返回对应的顶点下标 */
else return ERROR; /* 若这样的顶点不存在,返回错误标记 */
}
bool Dijkstra( MGraph Graph, int dist[], int path[], Vertex S )
{
int collected[MaxVertexNum];
Vertex V, W;
/* 初始化:此处默认邻接矩阵中不存在的边用INFINITY表示 */
for ( V=0; V<Graph->Nv; V++ ) {
dist[V] = Graph->G[S][V];
if ( dist[V]<INFINITY )
path[V] = S;
else
path[V] = -1;
collected[V] = false;
}
/* 先将起点收入集合 */
dist[S] = 0;
collected[S] = true;
while (1) {
/* V = 未被收录顶点中dist最小者 */
V = FindMinDist( Graph, dist, collected );
if ( V==ERROR ) /* 若这样的V不存在 */
break; /* 算法结束 */
collected[V] = true; /* 收录V */
for( W=0; W<Graph->Nv; W++ ) /* 对图中的每个顶点W */
/* 若W是V的邻接点并且未被收录 */
if ( collected[W]==false && Graph->G[V][W]<INFINITY ) {
if ( Graph->G[V][W]<0 ) /* 若有负边 */
return false; /* 不能正确解决,返回错误标记 */
/* 若收录V使得dist[W]变小 */
if ( dist[V]+Graph->G[V][W] < dist[W] ) {
dist[W] = dist[V]+Graph->G[V][W]; /* 更新dist[W] */
path[W] = V; /* 更新S到W的路径 */
}
}
} /* while结束*/
return true; /* 算法执行完毕,返回正确标记 */
}
多源最短路算法
给一篇很棒的参考博客,大话解析版的:https://www.cnblogs.com/Braveliu/p/3459768.html
理论上会了单源的多源的也就差不多了,是这样的吗?
哈哈没错,不过还有一种改进了的方法
叫Floyd 算法
基本思想
对于从vi到vj的弧,进行n次试探:首先考虑路径vi,v0,vj是否存在,如果存在,则比较vi,vj和vi,v0,vj的路径长度,取较短者为从vi到vj的中间顶点的序号不大于0的最短路径。在路径上再增加一个顶点v1,依此类推,在经过n次比较后,最后求得的必是从顶点vi到顶点vj的最短路径。
设计数据结构
1、图的存储结构:带权的邻接矩阵存储结构 。
2、数组dist[n][n]:存放在迭代过程中求得的最短路径长度。迭代公式:
3、数组path[n][n]:存放从vi到vj的最短路径,初始为path[i][j]="vivj"。
算法实现:
/* 邻接矩阵存储 - 多源最短路算法 */
bool Floyd( MGraph Graph, WeightType D[][MaxVertexNum], Vertex path[][MaxVertexNum] )
{
Vertex i, j, k;
/* 初始化 */
for ( i=0; i<Graph->Nv; i++ )
for( j=0; j<Graph->Nv; j++ ) {
D[i][j] = Graph->G[i][j];
path[i][j] = -1;
}
for( k=0; k<Graph->Nv; k++ )
for( i=0; i<Graph->Nv; i++ )
for( j=0; j<Graph->Nv; j++ )
if( D[i][k] + D[k][j] < D[i][j] ) {
D[i][j] = D[i][k] + D[k][j];
if ( i==j && D[i][j]<0 ) /* 若发现负值圈 */
return false; /* 不能正确解决,返回错误标记 */
path[i][j] = k;
}
return true; /* 算法执行完毕,返回正确标记 */
}