浅谈Floyd的三种用法 By cellur925

Floyd大家可能第一时间想到的是他求多源最短路的n³算法。其实它还有另外两种算法的嘛qwq。写一发总结好了qwq。

一、多源最短路

放段代码跑，注意枚举顺序，用邻接矩阵存图。本质是一种动规。

复杂度O(n³)。

for(int k=1;k<=n;k++)
    for(int i=1;i<=n;i++)
        for(int j=1;j<=n;j++)
            f[i][j]=min(f[i][j],f[i][k]+f[k][j]); 

放个例题跑。

灾后重建

二、传递闭包

在交际网络中，给定若干个元素，若干个二元关系，关系有传递性。传递闭包就是一种“通过传递性推导出尽量多的元素之间关系的问题”，求出可确定排名的元素个数。

实现用一个布尔型的邻接矩阵，f[i][j]=1表示i与j有关系，否则则没有关系。

我们每次可以枚举k点，来解决那些间接相关的关系处理。

for(int k=1;k<=n;k++)
    for(int i=1;i<=n;i++)
        for(int j=1;j<=n;j++)
            f[i][j]|=f[i][k]&f[k][j]; 

例题 [USACO08JAN]牛大赛Cow Contest

对于奶牛的编程能力，用f[i][j]=1表示i比j强，之后就是一个裸的传递闭包。跑一遍后n²统计每只牛它与其他牛的关系是否已经确定，意思就是说只要有f[i]j]=1或f[j][i]=1其中一个就行，来统计答案。

Code

#include<cstdio>
#include<algorithm>

using namespace std;

int n,m,ans;
int f[200][200];

int main()
{
    scanf("%d%d",&n,&m);
    for(int i=1;i<=m;i++)
    {
        int x=0,y=0;
        scanf("%d%d",&x,&y);
        f[x][y]=1;
    }
    for(int k=1;k<=n;k++)
        for(int i=1;i<=n;i++)
            for(int j=1;j<=n;j++)
                f[i][j]|=f[i][k]&f[k][j];
    for(int i=1;i<=n;i++)
    {
        int j;
        for(j=1;j<=n;j++)
        {
            if(i==j) continue;
            if(f[i][j]==0&&f[j][i]==0) break;
        }
        if(j>n) ans++;
    }
    printf("%d",ans);
    return 0;
}

三、求无向图最小环

例题1　USACO4.1篱笆回路 

这道题难在建图，图建好以后就是裸的跑floyd找最小环了。

（瞎说一句，这题竟然有个数组开了1000的空间，但是越界了呀qwq）

Code

/*
ID:cellur_2
TASK:fence6
LANG:C++
*/
#include<cstdio>
#include<algorithm>
#include<cstring>

using namespace std;
const int inf=0x3f3f3f3f;

int n,num,ans=inf;
int dis[300][300],mapp[300][300];
struct node{
    int len;
    int lcnt,rcnt,lid,rid,id;
    int l[300],r[300];
}edge[300];

int main()
{
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
    {
        scanf("%d",&edge[i].id);
        int x=edge[i].id;
        scanf("%d",&edge[x].len);
        scanf("%d%d",&edge[x].lcnt,&edge[x].rcnt);
        for(int j=1;j<=edge[x].lcnt;j++)
            scanf("%d",&edge[x].l[j]);
        for(int j=1;j<=edge[x].rcnt;j++)
            scanf("%d",&edge[x].r[j]);
    }
    for(int i=1;i<=n;i++)
    {// lid  这条边左端点的点编号
     // rid  这条边右端点的点编号  
        if(!edge[i].lid) edge[i].lid=++num;
        for(int j=1;j<=edge[i].lcnt;j++)
        {
            int x=edge[i].l[j];
            bool flag=0;
            for(int k=1;k<=edge[x].lcnt;k++)
                if(edge[x].l[k]==i) 
                {
                    flag=1;
                    break;
                }
            if(flag) edge[x].lid=edge[i].lid;
            else edge[x].rid=edge[i].lid;
        }
        if(!edge[i].rid) edge[i].rid=++num;
        for(int j=1;j<=edge[i].rcnt;j++)
        {
            int x=edge[i].r[j];
            bool flag=0;
            for(int k=1;k<=edge[x].lcnt;k++)
                if(edge[x].l[k]==i)
                {
                    flag=1;
                    break;
                }
            if(flag) edge[x].lid=edge[i].rid;
            else edge[x].rid=edge[i].rid;
        }
    }
    memset(mapp,0x3f,sizeof(mapp));
    memset(dis,0x3f,sizeof(dis));
    ans=dis[2][33];
    for(int i=1;i<=n;i++) mapp[i][i]=0,dis[i][i]=0;
    for(int i=1;i<=n;i++)
    {
        int lid=edge[i].lid;
        int rid=edge[i].rid;
        int len=edge[i].len;
        mapp[rid][lid]=mapp[lid][rid]=len;
        dis[rid][lid]=dis[lid][rid]=len;
    }    
    //floyd找最小环 
    for(int k=1;k<=num;k++)
    {
        for(int i=1;i<k;i++)
            for(int j=i+1;j<k;j++)
                ans=min(ans,dis[i][j]+mapp[i][k]+mapp[k][j]);
        for(int i=1;i<=num;i++)
            for(int j=1;j<=num;j++)
                dis[i][j]=min(dis[i][j],dis[i][k]+dis[k][j]);
    }
    printf("%d
",ans);
    return 0;
}

 例题2　POJ 1734 Sightseeing Trip

其实是floyd找最小环的板子题，但是由于题目要求输出一种合法的方案，所以我们只要再开一个vector就行了。

Code

#include<cstdio>
#include<algorithm>
#include<vector>
#include<cstring>

using namespace std;
typedef long long ll;

int n,m;
int ans=0x3f3f3f3f;
int dis[200][200],mapp[200][200],pos[200][200];
vector<int>path;

void get_path(int x,int y)
{
    if(pos[x][y]==0) return ;
    get_path(x,pos[x][y]);
    path.push_back(pos[x][y]);
    get_path(pos[x][y],y);
}

int main()
{
    scanf("%d%d",&n,&m);
    memset(dis,0x3f,sizeof(dis));
    for(int i=1;i<=n;i++) dis[i][i]=0;
    for(int i=1;i<=m;i++)
    {
        int x=0,y=0,z=0;
        scanf("%d%d%d",&x,&y,&z);
        dis[x][y]=dis[y][x]=min(dis[x][y],z);
    }
    memcpy(mapp,dis,sizeof(dis));
    for(int k=1;k<=n;k++)
    {
        for(int i=1;i<k;i++)
            for(int j=i+1;j<k;j++)
                if((ll)mapp[i][j]+dis[j][k]+dis[i][k]<ans) 
                {
                    ans=mapp[i][j]+dis[i][k]+dis[k][j];
                    path.clear();
                    path.push_back(i);
                    get_path(i,j);
                    path.push_back(j);
                    path.push_back(k);
                }
        for(int i=1;i<=n;i++)
            for(int j=1;j<=n;j++)
                if(mapp[i][j]>mapp[i][k]+mapp[k][j])
                {
                    mapp[i][j]=mapp[i][k]+mapp[k][j];
                    pos[i][j]=k;
                }
    }
    if(ans==0x3f3f3f3f) 
    {
        printf("No solution.");
        return 0;
    }
    for(int i=0;i<path.size();i++)
        printf("%d ",path[i]);
    return 0;
}