图论——Floyd算法拓展及其动规本质

一、Floyd算法本质

　　首先，关于Floyd算法：

　　Floyd-Warshall算法是一种在具有正或负边缘权重（但没有负周期）的加权图中找到最短路径的算法。算法的单个执行将找到所有顶点对之间的最短路径的长度（加权）。

　　通俗一点说，Floyd就是可以用于求解多源汇最短路径的算法，也就是求连通图中任意两点间的最短路径，当然，如果不连通，它返回的就是无穷大（初始化为无穷大）。Floyd可以处理负权，但无法处理有负权环的图。

　　接下去进入正题：

　　众所周知，Floyd算法本质其实是动态规划。它其实是由三维数组的DP优化而来。

　　我们用数组dis[i,j,k]表示从点i到点j，以前k个点作为中转点的最短路径长度。

　　为了实现状态转移，我们把当前dis[i,j,k]的所有状态的集合划分为两类，一类是经过k点的，一类是不经过k点的。对于前者，显然dis[i,j,k]=dis[i,j,k-1]；对于后者，我们可以得到dis[i,j,k]=dis[i,k,k-1]+dis[k,j,k-1]，也就是i到k的最短路径长度加上k到j的最短路径长度。于是我们便可以得到状态转移方程：

　　dis[i,j,k] = min(dis[i,j,k-1],dis[i,k,k-1]+dis[k,j,k-1]

　　边界条件：dis[i,j,0] = w[i,j]，即i与j之间的直接边的权值，若不存在则为正无穷；还有dis[i,i,0]=0。

　　代码如下：

void floyd_original() {
    for(int k=;k<=n;k++) {
        for(int i=;i<=n;i++) {
            for(int j=;j<=n;j++) {
                dis[i][j][k]=min(dis[i][j][k-],dis[i][k][k-]+dis[k][j][k-]);
            }
        }
    }
}

　　类比前面背包问题的优化方式，我们发现对于每一层k，它的状态计算只与第k-1层的状态有关，那么我们便可以省略这一维。因为省略之后，在计算第k层的dis[i,j]时，我们所需的dis[i,k]和dis[k,j]还是上一层的。

　　这一点用一个式子便可证明：

　　dis[i,k,k] = min(dis[i,k,k-1]，dis[i,k,k-1]+dis[k,k,k-1]) = min(dis[i,k,k-1], d[i,k,k-1]+0) = d[i,k,k-1]

　　dis[k,j]同理即可得证。

　　于是我们便可得到最普遍的二维数组的状态转移方程：

　　dis[i,j] = min(dis[i,j],dis[i,k]+dis[k,j])

　　从三维变成二维确实降低了空间开销，但是我们也可以发现时间复杂度是不变的，仍然是O(n³)。

二、Floyd算法变形解决有边数限制的最短路问题

　　我们用三维数组d[i,j,e]表示点i到点j，经过e条边的最短路径长度。

　　我们假设经过的倒数第二个点是k，那么我们很容易就可以得到状态转移方程：

　　d[i,j,e]=min{d[i,k,e-1]+w[k,j]} k∈[1,n]

　　代码如下：

for(int e=;e<=n;e++)
    for(int k=;k<=n;k++)
        for(int i=;i<=n;i++)
            for(int j=;j<=n;j++)
                d[i][j][e]=min(d[i][j][e],d[i,k,e-]+w[k][j]);

　　但是这样处理的时间复杂度高达O(n⁴)，于是我们自然会想到要做一些优化。

　　我们为了达到明显的指数级别的优化效果，我们选择二进制优化。

　　假设限制的边数为s时，我们把第三维e表示成2^e条边。那么我们预处理时只需要将2^e<s的所有符合条件的e枚举完即可。然后便可以用若干个2的整数次幂的和表示出s。

　　我们再用数组f[i,j,t]来表示状态，其中t表示边数为前t个2的整数次幂的和，那么我们就可以得到状态转移方程：

　　f[i,j,t] = min{f[i,k,t-1]+d[k,j,s(t)]}

　　其中s(t)表示将s进行2的指数幂分解后，所得的所有的2的幂中的第t个2的幂。k是i到j的最短路径中间经过的一个点，将路径中所有的边划分为前2⁰+2¹+…+2^t-1条与后2^t条。

　　那么我们就只需在最外层枚举k即可。这个算法的时间复杂度就可以降低到O(n³logn)。

算法思路：

　　先预处理出d数组，d[i,j,e]表示从顶点i到顶点j，经过2^k条边的最短路长度。找到中介点k，将路径边数分成两半。

　　状态转移方程如下：

　　d[i,j,e]=min(d[i,j,e],d[i,k,e-1]+d[k,j,e-1]}

　　然后处理f数组。

　　代码如下：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
using namespace std;
const int N = 1e3+;
const int K = log2(N);
int n,m,s;
int d[N][N][K],f[N][N][K]; //使用邻接矩阵存储图 
 
void floyd(int s) //有边数限制的最短路问题
{
    memset(f,0x3f,sizeof f);
    int z[K],max_e=log2(s); //s为所限制的边数 
 
    memset(z,,sizeof z);
 
    //先处理出s的2的指数次幂的分解，用z数组存储
    //如 p=2^1+2^4+2^5，则z[1]=1,z[2]=4,z[3]=5 
 
    int cnt=,sum=;
    while(s)
    {
        if(s&)z[++cnt]=sum;
        sum++;
        s>>=;
    }
 
    //处理d数组，d[i][j][k]表示从i到j经过2^k条边的最短路长度
    //复杂度 n^3*logs
    for(int e=;e<=max_e;e++)
        for(int i=;i<=n;i++)d[i][i][e]=; //处理d的边界
    for(int e=;e<=max_e;e++)
    {
        for(int k=;k<=n;k++)
            for(int i=;i<=n;i++)
                for(int j=;j<=n;j++)
                {
                    //状态转移方程如下
                    d[i][j][e]=min(d[i][j][e],d[i][k][e-]+d[k][j][e-]);
                    //找到中介点k，将2^e条边的最短路分成两半，分别是2^(e-1)条。
                }
    }
 
    for(int t=;t<=cnt;t++)
        for(int i=;i<=n;i++)f[i][i][t]=; //处理f的边界
    for(int t=;t<=cnt;t++)
    {
        for(int k=;k<=n;k++)
            for(int i=;i<=n;i++)
                for(int j=;j<=n;j++)
                {
                    //状态转移方程
                    f[i][j][t]=min(f[i][j][t],f[i][k][t-]+d[k][j][z[t]]);
                }
    } 
 
    printf("%d\n",f[][n][cnt]);
}
 
int main()
{
    scanf("%d%d%d",&n,&m,&s);
 
    memset(d,0x3f,sizeof d); // d数组的初始化 
 
    for(int i=;i<=m;i++)
    {
        int u,v,w;
        scanf("%d%d%d",&u,&v,&w);
        d[u][v][]=d[v][u][]=w; // d数组的赋值
    }
 
    floyd(s);
    return ;
}

关于算法适用范围：

　　个人认为，由于时间复杂度如此感人，相比于同样用于处理“有边数限制的最短路问题”的Bellman-Ford算法的最坏情况，也就是遇到完全图时，O(nm)变成O(n³)，也是过犹不及。

　　但是，当题目毒瘤到一定程度的时候，当出题人变态到一种境界的时候，边数极其之多，Bellman-Ford算法所用以存储图的边集数组所需的空间开销极大，超过限制时，就是这个算法大展拳脚的时候了。

　　大家对这个算法有兴趣的话可以去看一下这道题：POJ 3613