图论算法之最短路径

Posted 2020-06-20 jasonkent27

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

---

作者：jasonkent27
转载请注明出处：www.cnblogs.com/jasonkent27

1. 前言

1.1 最短路引入

小明和小天现在住在海口(C1)，他们俩计划暑假到三亚(C4)玩一趟，在海口和三亚之间有许多中间城市（文昌，临高，乐东，万宁...）图中的边上的数字是他们到达该城市必须的花费，现在需要你帮他们俩找出一条从海口到三亚的最省钱的路径出来。

---

等等，图中的边的weight怎么会有负的呢？你暂且可以这么理解吧。图中的边上的weight可以当作他们旅途中必须的花费，但是他们俩在去三亚图中把钱花光了(真是败家)不得不通过搬砖赚钱，通过搬砖赚的钱不仅抵掉他们应该的花费，而且还赚了点小钱(但是他们不能一直搬砖啊，不然他们早就累挂了，哪里还能去玩)。

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. 最短路径的几个性质

1. 最短路径具有最优子结构性质

2. 路径松弛性质

3. 上界性质

4. 收敛性质

5. 最短路径一定是简单路径

这几条性质是后面最短路算法的数学依据，如果想要彻底理解最短路的算法，有必要对其深究

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

即最短路径的子路径也是最短路径
简单证明：如果最短路径P的子路径不是最短路径，则可以找到一条更短的路径使得P更短，这与P是最短路径不符.

2.2 路径松弛性质

如果P=<v0,v1, ..., vk>是从源点s=v0到vk的一条最短路径，并且我们对P中的边所进行松弛的次序为(v0,v1),(v1,v2), ..., (vk-1,vk)，则dist[vk] = delta(s,vk)，why?
我们可以用归纳法进行证明：
1.当v = s,时 dist[v] = delta(s,s) = 0，显然成立
2.假设当v = vk-1时，dist[v] = delta(s,v) = delta(s,vk-1)成立，如果我们能推出dist[vk] = delta(s,vk)，则命题成立。
因为
dist[vk] >= dist[vk-1] + w(vk-1,vk)
= delta(s,vk-1) + w(vk-1,vk)
= delta(s,vk) (收敛性质)
则原命题也是成立的.

2.3 上界性质

对于所有节点v, 有dist[v] >= delta(s,v)，且当dist[v]=delta(s,v)之后，dist[v]的值不会再变化.
此性质亦可用归纳法证明：
1.进行init(v0)后，显然满足对所有v, dist[v] >= delta(s,v)
2.假设松弛前,对所有v, dist[v] >= delta(s,v)，我们只要再证明松弛后，该性质也成立，则原命题即能成立

2.4 收敛性质

假设s-->u-->v为s-->v的一条最短路径，在某个时刻dist[u] = delta(s,u)，则在边(u,v)松弛之后有dist[v] = delta(s,v)
证明：在边松弛之后应该有
dist[v] <= dist[u] + w(u,v)
= delta(s,u) + w(u,v)
= delta(s,v) （最短路最优子结构性质）
而根据上界性质，dist[v] >= delta(s,v)，因此dist[v] = delta(s,v)

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

why？ 为何最短路径一定是简单路径（即无环）？
理由如下：假设最短路径有环，则有以下三种情况：
1.正环，然后去掉正环会使最短路径更短，不符合
2.零环，零环对最短路径没有影响，可以去掉
3.负环，如果存在负环，则不会有最短路径，因为我循环一圈都可以是u到v的路径更短.

3. Bellman-Ford算法

3.1 算法思路

Bellman-Ford算法通过不断构建以源点为根的最短路径树，不断扩展.
简单来说，先找出，扩展一条边，源点到达其他节点的最短路径，再找出扩展两条边，源点到达其他节点的最短路径，以此类推，找到通过扩展n-1条边，源点到达其他节点的最短路径，算法完毕。因为我们知道最短路径是简单路径，因此它无环，所以它最多有n-1条边.算法思路类似bfs.其正确性可以用路径松弛性质证明.

示意图如下（图片来自算法导论）：

先是从s扩展一条边，可以达到t,y(图b)，此时我们知道，在只扩展一条边的前提下，s到t,y的最短路径分别是dist[t],dist[y]，然后再通过t,y继续扩展边(图c)，这时我们有，在只扩展两条边的前提下，s到x,z的最短路径分别是dist[x],dist[z]。当然有个前提假设是s到其他节点都有最短路径.看看整个过程有没有觉得特别像通过bfs找最短路的过程.

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 算法思想

我们可以轻松知道Bellman-Ford算法的时间复杂度是O(nm)的，我们再想想，是不是每次都需要对M条边进行松弛操作的，显然没必要，而且我们发现如果在某次循环中，发现对M条不管怎么relax，dist数组都不会变化，那么算法就可以停止了(上界性质).SPFA算法就是在这2点上对Bellman-Ford算法进行优化的。SPFA算法时间复杂度为O(qm)，其中q远远小于n.在实战中有不错的效率，不过可以造出让SPFA效率低的数据。因此在如果题目没有负边，个人倾向于基于优先队列实现的Dijkstra算法.

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 算法思路

维护集合U,用来保存那些已经计算过最短路的节点即dist[v] = delta(s,v)的节点，不断增大集合U,直到U包含图中所有节点.
1.选出V-U集合中最小的dist[x]
2.把x加入到U中
3.用dist[x]去更新所有V-U集合的所有节点dist值，(U集合中的dist值已经达到下限delta(s,v)了，没必要再更新)

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 算法引入

floyd算法用来求图中任意点对之间的最短路径.将floyd算法之前我们先来看看另外一个用O(V^4)来解决图中任意点对之间最短路径的算法。

通过前面的知识我们知道，任意两个节点之间的最短路径无非就两种情况
1.i, j 直接相连
2.i, j 间接相连
若是直接相连，则delta(i,j) = g[i][j] ;
若间接相连，设其路径为i------>k-->j(k为j前驱)，则有
delta(i,j) = delta(i,k) + g[k][j] (收敛性质)
我们定义dist[m][i][j] 表示最多可以通过m条边,节点i,j之间的最短距离，则有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])，其中1<=k<=V，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 算法思路

OK，热身结束！我们来看看floyd算法，上面算法类似于Bellman_Ford,他们都是从路径中边的性质来考虑的。现在我们换个思路，从中间节点开始考虑，考虑节点i,j间最短路径p与中间节点均取自{1,2,...,k-1}的关系.

• 如果节点k不是路径p上的中间节点，则节点i,j路径上的中间节点均取自{1,2,...,k-1}的最短路径也是节点i,j路径上的中间节点均取自{1,2,...,k}的最短路径

• 如果节点k是路径p上的中间节点，则我们可以把路径分解成i--->k--->j，对于路径i-->k，其路径上的节点也肯定全部来自{1,2,...,k-1}，因为k不是路径i-->k的中间节点，路径k-->j同理,看下图:
  

因此我们可以定义d[k][i][j] 表示i,j之间节点编号最大为k时的最短距离，我们有
d[k][i][j] = min(d[k-1][i][j], d[k-1][i][k]+d[k-1][k][j])
当然d[k][i][j]也是可以降维成d[i][j].其中1<=k<=V，d[0][i][j] = g[i][j].

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] ;
    }

后记

本文对求最短路径的几种基本算法做了简单的讲解，力求做到简单，易懂，更严格的算法正确性的证明可以查阅参考书目，文中有任何错误之处请指出，我会尽快改正.另外有何问题，欢迎留言讨论.

参考书目

《算法导论》 第三版