使用 Warshall（沃舍尔）算法求解关系的传递闭包

1.离散数学定义：

t(R) = R u R^2 u R^3 u..... 其中R^(n+1) = R^n 复合 R

矩阵表示：

M（R） = M + M^2 + M^3 +....+M^n(其中加为逻辑加）

所以我们只要按照这个公式每次更新M，最后的Mn就是传递闭包

 

2.Warshall算法：

(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.在动态规划思想上实现沃舍尔算法

(1)这个算法类似于最短路的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;
}

4.POj 3660 Cow Contest

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

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

（3）代码：

​#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;
}

 

————————————————
原文链接：https://blog.csdn.net/qq_40772692/article/details/80351390