【数论系列】 Warshall（沃舍尔）算法求传递闭包

目录

一. 算法概述

1. 离散数学定义

2. Warshall算法

3. Warshall与floyd

二. 例题分析

---

一. 算法概述

1. 离散数学定义

        在离散数学中，令关系集合为R^i，则所有元素的最终传递闭包为：

                               

        在图论中，令M^i为前i个节点的邻接矩阵/可达矩阵，则所有图节点的最终传递闭包的矩阵表示如下，其中+为逻辑加：

                             

2. Warshall算法

        Warshall在1962年提出了一个求关系的传递闭包的有效算法。其具体过程如下，设在n个元素的有限集上关系R的关系矩阵为M：

（1）置新矩阵A＝M； 

（2）i＝1； 

（3）对所有j执行，如果A[j，i]＝1，则对k＝1，2，…，n，令A[j，k]＝A[j，k]∨A[i，k]； 

（4）i加1；（i是行，j是列） 

（5）如果i≤n，则转到步骤（3），否则停止。 、

        不难理解，上述过程可以简化为对于每个相通的j - > i关系，我们可以从这个相通关系出发，看看能不能通过这条相通的j - > i来更新一下j - >k。对所有的可通关系都更新一遍M，最后的结果就是传递闭包了！其实现代码如下：

#include <iostream>
#include<cstring>
using namespace std;
const int maxn = 100;
int G[maxn][maxn];//离散数学定义法
int main()
{
    int T;
    cin>>T;
    while(T--){
        memset(G,0,sizeof(G));
        int n,m;
        cin>>n>>m;//n个点m条边
        for(int i = 1;i<=m;i++){
            int a,b;
            cin>>a>>b;
            G[a][b] = 1;//建边
        }
        for(int i =1;i<=n;i++){//外层枚举到达点
            for(int j = 1;j<=n;j++){//内层枚举出发点
                if(G[j][i]){//如果j - >i相通
                    for(int k = 1;k<=n;k++){//从这条通路出发，更新所有的传递关系
                        G[j][k] = G[j][k]|G[i][k];（若G[j][k] = 0,但G[j][k] = G[j][i] 复合 G[i][k])
                    }

                }
            }
        }
        for(int i = 1;i<=n;i++){
            for(int j = 1;j<=n;j++){
                cout<<G[i][j]<<" ";
            }
            cout<<endl;
        }
    }
    return 0;
}

3. Warshall与floyd

       Warshall算法类似于最短路的floyd算法，可以说floyd是在更新传递闭包的基础上记录生成传递闭包的最小代价，这个最小代价就是最短路。所以说，最短路和沃舍尔求传递闭包的思想是一样的或者是相通的！

#include <iostream>
#include<cstring>
using namespace std;
const int maxn = 100;
int G[maxn][maxn];
int main()
{
    int T;
    cin>>T;
    while(T--){
        memset(G,0,sizeof(G));
        int n,m;
        cin>>n>>m;
        for(int i = 1;i<=m;i++){
            int a,b;
            cin>>a>>b;
            G[a][b] = 1;
        }
        for(int k = 1;k<=n;k++){//经过节点k中转，能更新多少传递关系
            for(int i = 1;i<=n;i++){
                for(int j = 1;j<=n;j++){
                    if(G[i][j])continue;
                    G[i][j] = (G[i][k]&&G[k][j]);
                }
            }
        }
        for(int i = 1;i<=n;i++){
            for(int j = 1;j<=n;j++){
                cout<<G[i][j]<<" ";
            }
            cout<<endl;
        }
    }
    return 0;
}

二. 例题分析

POj 3660 Cow Contest

有n头牛互相比赛，现在给出m种已知的比赛结果。注：若A打败B，B打败C，则A可以打败C。问你根据这个表最终能确定几头牛的排名。

        能确定排名的肯定是和其他所有的牛的关系间接或者直接的知道了，所以这里等价于求关系的传递闭包。某头牛的所有入度和出度之和等于n - 1时表示这头牛和其他所有牛的关系都有了那么这头牛的排名肯定就确定了。其题解代码如下：

​#include <iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int maxn = 100+5;
int G[maxn][maxn];
int main()
{
    int n,m;
    memset(G,0,sizeof(G));
    scanf("%d%d",&n,&m);
    for(int i = 0;i<m;i++){
        int a,b;
        scanf("%d%d",&a,&b);
        G[a][b] = 1;
    }
    for(int k = 1;k<=n;k++){//求传递闭包
        for(int i = 1;i<=n;i++){
            for(int j = 1;j<=n;j++){
                if(i==j||G[i][j])continue;
                else if(G[i][k] == 1&&G[k][j]==1)G[i][j]  = 1;
            }
        }
    }
    int ans = 0;//统计总的可确定排名牛的数目
    for(int i = 1;i<=n;i++){
        int sum = 0;//统计编号i牛的度数和
        for(int j = 1;j<=n;j++){
            if(i==j)contiue;
            if(G[i][j]||G[j][i])sum++;
        }
        if(sum==n-1)ans++;
    }
    printf("%d\n",ans);
    return 0;
}

​