Floyd

Floyd

• 本质：DP

• 存储结构：邻接矩阵，若有重边则读入时必须取最小边

• 算法特点：多源最短路，能一次性求解所有点对间的最短距离

• 适用对象：小图，允许负权图，无法适用于负环图(负环:环上边权之和为负的环,当任意时刻出现$dp[i][i]<0$时则有负环)

• 核心思想：考查每个点作为中转点，尝试每一点对距离是否能通过中转点被松弛

• 算法流程：闫氏DP分析法

  • 状态表示：

    • 集合：设$i$为当前轮源点，$j$为当前轮终点，$k$为当前轮中转点。定义状态矩阵$d{p}_k[i][j]$，表示在$i$到$j$的路径上，所经过的顶点编号$\le k$的最短路长度(初始化为$+\infty$表示该点不可达，主对角线初始化为$0$)。路径矩阵$pat{h}_k[i][j]$表示考查第$k$个顶点之后，$j$点的上一个来源顶点(初始化为$-1$表示无路径)。
    • 属性：$Min$
    • 初始化：初始状态即为原邻接矩阵

  • 状态计算：$d{p}_k[i][j]$：对于第$k$个顶点，此处确保第$k$个点一定可选(与其他dp问题不同)

    • 不选第$k$个点：若选择第$k$个点作为中转点无法对$i$到$j$路径进行松弛(无法保证最优)，则不选。路径状态仍为$[i,j]$，直接继承自$k-1$个顶点时$i$到$j$的路径。$d{p}_k[i][j]=d{p}_{k-1}[i][j]$。
    • 选第$k$个点：选择第$k$个点作为中转点会使$i$到$j$的路径松弛，则选第$k$个点。路径状态变更为$[i,k],[k,j]$，继承自$k-1$个顶点时$i$到$k$，$k$到$j$的路径，并相加。$d{p}_k[i][j]=d{p}_{k-1}[i][k]+d{p}_{k-1}[k][j]$。

  • 状态转移方程式：$d{p}_k[i][j]=min(d{p}_{k-1}[i][j],d{p}_{k-1}[i][k]+d{p}_{k-1}[k][j])$。

• 复杂度：$O(V^3)$

Floyd在大多数情形下必须使用自我滚动将空间复杂度降低到$O(V^2)$才能使用。下面仍给出朴素版供对比。

朴素版

using ll=long long;
const ll INF=__LONG_LONG_MAX__;
extern ll dp[MAXV][MAXV][MAXV],path[MAXV][MAXV][MAXV];//dp[0][MAXV][MAXV]已默认存储图的边权数据的最小值
extern ll n;//点数
void floyd(){
    for(ll k=0;k<n;k++){
        for(ll i=0;i<n;i++){
            for(ll j=0;j<n;j++){
                if(dp[k-1][i][k]!=INF&&dp[k-1][k][j]!=INF&&dp[k-1][i][j]>dp[k-1][i][k]+dp[k-1][k][j]){//松弛操作,特判!=INF是为了防止数据溢出
                    dp[k][i][j]=dp[k-1][i][k]+dp[k-1][k][j];
                    path[k][i][j]=path[k-1][k][j];
                }
                else{
                    dp[k][i][j]=dp[k-1][i][j];
                    path[k][i][j]=path[k-1][i][j];
                }
            }
        }
    }
}

滚动数组优化

交替滚动

using ll=long long;
const ll INF=__LONG_LONG_MAX__;
extern ll dp[2][MAXV][MAXV],path[2][MAXV][MAXV];//dp[0][MAXV][MAXV]已默认存储图的边权数据的最小值
extern ll n;//点数
void floyd(){
    ll work=0,old=1;
    for(ll k=0;k<n;k++){
        swap(work,old);
        for(ll i=0;i<n;i++){
            for(ll j=0;j<n;j++){
                if(dp[old][i][k]!=INF&&dp[old][k][j]!=INF&&dp[old][i][j]>dp[old][i][k]+dp[old][k][j]){//松弛操作,特判!=INF是为了防止数据溢出
                    dp[work][i][j]=dp[old][i][k]+dp[old][k][j];
                    path[work][i][j]=path[old][k][j];
                }
                else{
                    dp[work][i][j]=dp[old][i][j];
                    path[work][i][j]=path[old][i][j];
                }
            }
        }
    }
}

自我滚动

using ll=long long;
const ll INF=__LONG_LONG_MAX__;
extern ll dp[MAXV][MAXV],path[MAXV][MAXV];//dp[MAXV][MAXV]已默认存储图的边权数据的最小值
extern ll n;//点数
void floyd(){
    for(ll k=0;k<n;k++){//依次考查每个点作为中转点
        for(ll i=0;i<n;i++){//依次考查每个点作为源点
            //if(dp[i][k]!=INF&&i!=k) //此处为小优化,提前判断,若常规写法T掉可尝试
            for(ll j=0;j<n;j++){//依次考查每个点作为终点
                if(dp[i][k]!=INF&&dp[k][j]!=INF&&dp[i][j]>dp[i][k]+dp[k][j]){
                    //松弛的3个条件:中转点dis非无穷,中转点到终点dis非无穷,通过中转点使源点到终点距离更短
                    dp[i][j]=dp[i][k]+dp[k][j];
                    path[i][j]=path[k][j];
                }
            }
        }
    }
}

路径输出

void print(ll s,ll t){
    if(s==t){
        cout<<s<<' ';
        return;
    }
    print(s,path[s][t]);
    cout<<t<<' ';
}

应用:传递闭包

传递闭包：求所有元素间的传递连通关系

算法流程：定义状态数组$dp[i][j]$，表示$i$与$j$的连通性(直接/间接到达)。当$i$与$j$连通时，$dp[i][j]=1$；否则$dp[i][j]=0$

朴素版($O(V^3)$)

void floyd(){
    for(int k=0;k<n;k++)
        for(int i=0;i<n;i++)
            //if(dp[i][k])//小优化,提前判断,若T掉可尝试
            for(int j=0;j<n;j++)
                if(dp[i][k]&&dp[k][j])
                    dp[i][j]=1;//6-7行可合并为dp[i][j]|=dp[i][k]&dp[k][j]
}

bitset优化($O(V^2)$)

bitset<N>d[N];
void floyd(){
    for(int k=0;k<n;k++)
        for(int i=0;i<n;i++)
            if(d[i][k]) d[i]|=d[k];
}