floyd(传递闭包)

题目:点击打开链接

代码:

#include <iostream>
#include <string.h>
#include <algorithm>
#include <stdio.h>
using namespace std;
const int MAXN=110;
int win[MAXN][MAXN];
int main()
{
    int n,m;
    while(scanf("%d%d",&n,&m)==2)
    {
        memset(win,0,sizeof(win));
        int u,v;
        while(m--)
        {
            scanf("%d%d",&u,&v);
            win[u][v]=1;
        }
        for(int k=1;k<=n;k++)
            for(int i=1;i<=n;i++)
                for(int j=1;j<=n;j++)
                    if(win[i][k]&&win[k][j])
                        win[i][j]=1;
        int ans=0;
        int j;
        for(int i=1;i<=n;i++)
        {
            for(j=1;j<=n;j++)
            {
                if(i==j)continue;
                if(win[i][j]==0&&win[j][i]==0)break;//关系不确定
            }
            if(j>n)ans++;
        }
        printf("%d\n",ans);
    }
    return 0;
}
比较新,刚开始没有想到,算法真是博大精深, 这几天接触的有好多最短路的问题,感觉题·都是比较新的,特别是优化的这块,太弱啊,还是对算法的理解不够深刻。

<think>嗯,我现在要理解Floyd算法如何用于计算图的传递闭包。首先,我需要回忆一下Floyd算法的基本概念。根据之前学过的内容,Floyd算法原本是用来解决所有顶点对之间最短路径的问题的,它通过动态规划的方法,逐步更新每对顶点之间的距离。引用中提到,Floyd算法可以处理带有负权边但没有负权环的图,这说明它的核心在于三重循环遍历所有顶点,不断优化路径信息。[^1] 那传递闭包又是什么呢?传递闭包应该是在图中确定顶点之间是否存在可达的路径。例如,如果有边从A到B,B到C,那么传递闭包会包含A到C的关系。这时候,问题就转化为如何利用Floyd算法来计算这种传递关系。根据引用[2],传递闭包可以用Floyd算法来计算,具体来说,通过设置一个二维数组dis[a][b]来表示a和b之间的关系是否存在,并通过三重循环来更新这个关系。[^2] 接下来,我需要理清Floyd算法如何调整以适用于传递闭包的计算。原Floyd算法中的状态转移方程可能是这样的:dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j])。但对于传递闭包来说,我们关心的不是距离的最小值,而是是否存在路径。因此,状态转移的逻辑应该改为:如果存在i到k的路径和k到j的路径,那么i到j也存在路径。也就是说,dis[i][j] = dis[i][j] | (dis[i][k] & dis[k][j])。这里的逻辑或和逻辑与代替了原来的加法和取最小值操作。 我需要验证这个转换是否正确。假设dis[i][k]为真,表示i到k有路径,dis[k][j]也为真,那么i到j自然有路径。通过遍历所有中间节点k,逐步更新所有i和j的关系,这样就可以得到传递闭包。这和Floyd算法的三重循环结构是一致的,即外层循环遍历中间节点k,内层两层循环遍历i和j。 那么具体的实现步骤应该是怎样的呢?首先,初始化一个二维数组,比如reach,其中reach[i][j]为1表示存在i到j的直接边,否则为0。然后,对于每个中间节点k,检查所有i和j,如果i到k可达且k到j可达,那么i到j也是可达的,于是将reach[i][j]设为1。这个过程需要重复对所有k进行处理,确保所有可能的中间节点都被考虑进去。 举个例子,假设有一个有向图,顶点0到1有边,1到2有边,但0到2没有直接边。初始时,reach[0][1]=1,reach[1][2]=1,其他为0。当k=1时,检查i=0,j=2,因为reach[0][1]和reach[1][2]都为1,所以reach[0][2]会被更新为1,这样就通过中间节点1找到了0到2的路径。 这样看来,Floyd算法确实能够有效地计算传递闭包,通过动态规划的方式逐步构建可达性矩阵。它的时间复杂度是O(),因为有三重循环,适用于顶点数不是特别大的图。 不过,可能会有疑问,为什么Floyd算法适合这种情况?因为传递闭包本身需要所有顶点对的路径信息,而Floyd的结构正好覆盖了所有可能的中间节点,从而确保所有路径的可能性都被检查到。这和最短路径中的松弛操作类似,只不过在这里是逻辑上的“或”和“与”操作。 总结一下,Floyd算法在传递闭包中的应用是将原本处理距离的方式转换为处理布尔值,通过三重循环不断更新可达性矩阵,直到所有可能的路径都被考虑进去。这种方法虽然时间复杂度较高,但在实现上较为简单,适合小规模的图或者对性能要不高的场景。</think>### Floyd算法计算传递闭包的实现原理 Floyd算法通过动态规划思想逐步更新顶点间的可达性关系,最终得到传递闭包。以下是具体实现步骤: 1. **定义可达性矩阵** 设$reach[i][j]$表示顶点$i$到$j$是否存在直接或间接路径。初始时,若存在边$i \to j$,则$reach[i][j] = 1$,否则为$0$。 2. **三重循环更新规则** Floyd算法的核心是通过中间节点$k$更新所有顶点对的可达性: $$ reach[i][j] = reach[i][j] \ \lor \ \left( reach[i][k] \ \land \ reach[k][j] \right) $$ 即若存在路径$i \to k$和$k \to j$,则$i \to j$可达[^2]。 3. **代码实现** ```python def transitive_closure(graph, n): reach = [[0]*n for _ in range(n)] # 初始化可达性矩阵 for i in range(n): for j in range(n): reach[i][j] = graph[i][j] # Floyd-Warshall算法核心 for k in range(n): for i in range(n): for j in range(n): reach[i][j] = reach[i][j] or (reach[i][k] and reach[k][j]) return reach ``` 4. **示例分析** 对于图$0 \to 1 \to 2$,初始$reach$矩阵为: $$ \begin{bmatrix} 0 & 1 & 0 \\ 0 & 0 & 1 \\ 0 & 0 & 0 \end{bmatrix} $$ 经过计算后,$reach[0][2]$被更新为$1$,表示通过中间节点$1$可达。 --- ### 应用场景与特性 - **适用场景**:社交网络关系推导、编译器数据流分析、任务依赖关系判断等需要明确传递性的场景。 - **时间复杂度**:$O(n^3)$,与标准Floyd算法一致。 - **空间复杂度**:$O(n^2)$,存储可达性矩阵。 ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值