.[算法]图论专题之最短路径

.[算法]图论专题之最短路径

1. 前言

1.1 最短路引入

1.2 松弛技术

对于每个节点v,我们用dist[v] 来表示原点s到v的估算距离，用delta(s,v)表示s到v的最短距离

void relax(int u, int v, int w)
{
if ( dist[v]> dist[u] + w )
dist[v] = dist[u] + w ;
}

1.3 初始化

void init(int v0)
{
for (int i = 1 ; i <= n ; i ++)
dist[i] = infinity ;
dist[v0] = 0 ;
}

2. 最短路径的几个性质

2.1 最短路径的最优子结构性质

2.2 路径松弛性质

2.3 上界性质

2.4 收敛性质

2.4 最短路径一定是简单路径

3. Bellman-Ford算法

3.1 算法思路

3.2 算法伪代码

bool Bellman_Ford(int v0)
{
init(v0) ;
for(int i=1 ; i<=n-1 ; i++)
for(int j=1 ; j<=m ; j++)
relax(edge[j].u,edge[j].v,edge[j].w);
for(int i=1 ; i<=m ; i++)
{
int u = edge[i].u ;
int v = edge[i].v ;
int w = edge[i].w ;
if (dist[v] > dist[u] + w)
return false ;
}
return false ;
}

4. SPFA算法

4.1 算法思想

4.2 算法伪代码

void SPFA(int v0)
{
queue<int> q ;
init(v0) ;
q.push(v0) ;
inq[v0] = true ;
while (!q.empty())
{
int u = q.front(); q.pop();
inq[u] = false ;
for (int i=1 ; i<=n ; i++) //此处若用邻接表则更快
if (g[u][i] !=0 && dist[i] > dist[u]+g[u][i])
{
dist[i] = dist[u]+g[u][i] ;
if (inq[i] == false)
{
q.push(i);
inq[i] = true ;
}
}
}
}

5. Dijkstra算法

5.1 算法思路

5.2 算法伪代码

void Dijkstra(int v0)
{
init(v0) ;

for (int i=1 ; i<=n-1 ; i++)
{
min = infinity ;
for (int j=1 ; j<=n ; j++)
if (!inq[j] && dist[j]<min)
{
min = dist[j] ;
k = j ;
}
inq[k] = true ;
for(int j = 1 ; j<=n ; j++)
if (!inq[j] && dist[j]>dist[k]+g[k][j])
dist[j]>dist[k]+g[k][j] ;
}
}

5.3 算法理解

算法执行过程



1.首先从V-U集合中选出dist值最小的节点s(图a)，然后拿它去更新其他节点(图b)

2.把节点s加入到U集合中

3.不断重复此过程，直到U=V位置(图c,d,e,f)

要证明算法的正确性，我们只需要证明当节点u加入到集合U时，有dist[u]=delta(s,u)即可.

用反证法：假设u是第一个加入到集合U时，满足dist[u] != delta(s,u)的节点.

由于节点s是第一个加入到集合U的，并且有dist[s] = delta(s,s)=0，因此节点u与节点s必然不同，因此一定存在某条从节点s到节点u的路径，否则dist[u] = infinity，是不会被选入集合U中的.因为至少存在一条从s到u的路径，因此也存在一条从s到u的最短路径.



考虑这样一条路径s---->x-->y---->u，其中,s,x在集合U中，y，u在V-U集合中，

因为x在u加入之前就已经加入到U集合中了，因此有dist(x) = delta(s,x)，而x是y前驱，对边(x,y) relax后，有dist[y] = > delta(s,y)(收敛性质)

因为y是u的前驱，且边权值非负，因此有dist[y] = delta(s,y) <=delta(s,u)<=dist[u].

另外，算法选择u节点放进集合U的前提是u是所有V-U集合中dist值最小的，因此有dist[y] >= dist[u].

综上，有dist[y] = dist[u] = delta(s,u).这与假设dist[u] != delta(s,u)不符.因此原命题是成立的.

6. floyd算法

6.1 算法引入

dist[m][i][j] = min(dist[m-1][i][j],dist[m-1][i][k] + g[k][j]) = min(dist[m-1][i][k] + g[k][j])

dist[0][i][j] = g[i][j]

void Shortest_Path_Pair()
{
for (int u = 1 ; u<=n-1 ; u++) //因为最短路最多只有n-1条边
for (int i=1 ; i<=n ; i++)
for (int j = 1 ; j<=n ;j++ )
for (int k=1 ; k<=n ; k++)
//当然此处dist[u][i][j]可以降维成dist[i][j].
dist[u][i][j] = min(dist[u-1][i][j],dist[u-1][i][k]+g[k][j]) ;
}

6.2 算法思路

6.3 伪代码

void Floyd()
{
for (int k = 1 ; i<=n ; k++)
for (int i = 1; i<=n ; i++)
for (int j = 1 ; j<=n ; j++)
if (d[i][j] > d[j][k] + d[k][j])
d[i][j] = d[j][k] + d[k][j] ;
}

后记

参考书目