图论------有向图的连通性问题

其他 2021-01-30 03:30:29 阅读次数: 0

前言：

一些概念需要我们理解一下，以便更好地进行下面的内容。

  • 在有向图G中，如果两个顶点间至少存在一条互相可达路径，称两个顶点强连通(strongly connected)。
  • 如果有向图G的每两个顶点都强连通，称G是一个强连通图。
  • 非强连通图有向图的极大强连通子图，称为强连通分量(strongly connected components)。
很明显强连通分量出现在有向有环图中，每一个连通的分量都可以被当作是强连通分量。如左下图每一个虚线框内都是一个强连通分量（ＳＣＣ），右下图则将强连通分量当作一个结点后构成的一个DAG

在这里插入图片描述

解决方法：Tarjan算法

Tarjan算法基于深度优先搜索树，其有两个重要变量dfn[u]：表示在深度搜索中遍历到该节点的次序(设置一个时间戳变量即可)。low(u)表示以u节点为树根，u及u以下树节点所能找到的最小次序号。
注意Tarjan认为单个节点自身就是一个强联通分量

void tarjan(int u)
{
    dfn[u] = low[u] = ++ timestamp;    //先给遍历的点设置上时间戳
    stk[ ++ top] = u, in_stk[u] = true;　　　//入栈

    for (int i = h[u]; ~i; i = ne[i])
    {
        int j = e[i];
        if (!dfn[j])
        {
            tarjan(j);
            low[u] = min(low[u], low[j]);　　　　//这里表示已经遍历完u的某一个后继节点，需要更新low[u],low的定义参照上面所述
        }
        else if (in_stk[j])　　//看是否在栈里，如果在，证明该点所连接的点没有分到哪个ＳＣＣ上，所以就可以继续更新low[u]
            low[u] = min(low[u], dfn[j]);
    }

    if (dfn[u] == low[u])　　//这里是某个ＳＣＣ上的第一个入栈的点一定是整个ＳＣＣ都能达到的最小时间戳，可以简单地认为这个就是老大，虽然ＳＣＣ是个环
    {
        ++ scc_cnt;
        int y;
        do {
            y = stk[top -- ];
            in_stk[y] = false;
            id[y] = scc_cnt;　　　//表示该点是哪个ＳＣＣ
        } while (y != u);                //这里还可以统计ＳＣＣ内部的节点个数
    }
}

这里有一篇博客，讲low数组的含义还不错，请点击！

这里我们用例题来深入了解这个算法

例题一：

在这里插入图片描述
在这里插入图片描述
思路：
TarjanTarjan 缩点将原图转化成 DAG，统计每个强连通分量的出度入度，起点数量为 srcsrc，终点数量为 desdes。对于一个强连通分量，其中只要有一所学校获得新软件那么整个分量都能获得。很明显只要统计一下入度为０　的SCC个数，即就是第一问的答案

第二问，其实就是求添加多少条边能使缩点后的ＤＡＧ图变成一个强连通图，而这个做法也是有向图的强连通分量的后续操作，也就是把每个ＳＣＣ求出来后，你会发现把这些"缩点"后（常做的方法就是统计出入度即可，不需要真正的缩点，但有时是要建立图的），就形成了ＤＡＧ图，很明显就可以转换成拓扑排序，而且这还有个性质，如果我们按照ＳＣＣ的编号从大到小遍历，那么我们就是按照拓扑排序进行遍历的。
这里有个规律，统计入度为０的个数和出度为０的个数，那么添加的边的条数就是cnt = max(p,q);

#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;

const int N = 110, M = 10010;

int n;
int h[N], e[M], ne[M], idx;
int dfn[N], low[N], timestamp;
int stk[N], top;
bool in_stk[N];
int id[N], scc_cnt;
int din[N], dout[N];

void add(int a, int b)
{
    e[idx] = b, ne[idx] = h[a], h[a] = idx ++ ;
}

void tarjan(int u)
{
    dfn[u] = low[u] = ++ timestamp;    //先给遍历的点设置上时间戳
    stk[ ++ top] = u, in_stk[u] = true;　　　//入栈

    for (int i = h[u]; ~i; i = ne[i])
    {
        int j = e[i];
        if (!dfn[j])
        {
            tarjan(j);
            low[u] = min(low[u], low[j]);　　　　//这里表示已经遍历完u的某一个后继节点，需要更新low[u],low的定义参照上面所述
        }
        else if (in_stk[j])　　//看是否在栈里，如果在，证明该点所连接的点没有分到哪个ＳＣＣ上，所以就可以继续更新low[u]
            low[u] = min(low[u], dfn[j]);
    }

    if (dfn[u] == low[u])　　//这里是某个ＳＣＣ上的第一个入栈的点一定是整个ＳＣＣ都能达到的最小时间戳，可以简单地认为这个就是老大，虽然ＳＣＣ是个环
    {
        ++ scc_cnt;
        int y;
        do {
            y = stk[top -- ];
            in_stk[y] = false;
            id[y] = scc_cnt;　　　//表示该点是哪个ＳＣＣ
        } while (y != u);                //这里还可以统计ＳＣＣ内部的节点个数
    }
}

int main()
{
    cin >> n;
    memset(h, -1, sizeof h);
    for (int i = 1; i <= n; i ++ )
    {
        int t;
        while (cin >> t, t) add(i, t);
    }

    for (int i = 1; i <= n; i ++ )
        if (!dfn[i])
            tarjan(i);

    for (int i = 1; i <= n; i ++ )　　　　　　　　//这个就是缩点，并未真正的建图
        for (int j = h[i]; j != -1; j = ne[j])
        {
            int k = e[j];
            int a = id[i], b = id[k];
            if (a != b)
            {
                dout[a] ++ ;
                din[b] ++ ;
            }
        }

    int a = 0, b = 0;
    for (int i = 1; i <= scc_cnt; i ++ )
    {
        if (!din[i]) a ++ ;
        if (!dout[i]) b ++ ;
    }

    printf("%d\n", a);
    if (scc_cnt == 1) puts("0");
    else printf("%d\n", max(a, b));

    return 0;
}
例题二：

在这里插入图片描述
在这里插入图片描述

思路：这里就是先求ＳＣＣ，保存每个ＳＣＣ的内部节点个数，然后进行缩点加判断，如果出现两个以上出度为０的ＳＣＣ，那么就无解。

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;

const int N = 10010, M = 50010;

int n, m;
int h[N], e[M], ne[M], idx;
int dfn[N], low[N], timestamp;
int stk[N], top;
bool in_stk[N];
int id[N], scc_cnt, Size[N];
int dout[N];

void add(int a, int b)
{
    e[idx] = b, ne[idx] = h[a], h[a] = idx ++ ;
}

void tarjan(int u)
{
    dfn[u] = low[u] = ++ timestamp;
    stk[ ++ top] = u, in_stk[u] = true;
    for (int i = h[u]; i != -1; i = ne[i])
    {
        int j = e[i];
        if (!dfn[j])
        {
            tarjan(j);
            low[u] = min(low[u], low[j]);
        }
        else if (in_stk[j]) low[u] = min(low[u], dfn[j]);
    }

    if (dfn[u] == low[u])
    {
        ++ scc_cnt;
        int y;
        do {
            y = stk[top -- ];
            in_stk[y] = false;
            id[y] = scc_cnt;
            Size[scc_cnt] ++ ;
        } while (y != u);
    }
}

int main()
{
    scanf("%d%d", &n, &m);
    memset(h, -1, sizeof h);
    while (m -- )
    {
        int a, b;
        scanf("%d%d", &a, &b);
        add(a, b);
    }

    for (int i = 1; i <= n; i ++ )
        if (!dfn[i])
            tarjan(i);

    for (int i = 1; i <= n; i ++ )
        for (int j = h[i]; ~j; j = ne[j])
        {
            int k = e[j];
            int a = id[i], b = id[k];
            if (a != b) dout[a] ++ ;
        }

    int zeros = 0, sum = 0;
    for (int i = 1; i <= scc_cnt; i ++ )
        if (!dout[i])
        {
            zeros ++ ;
            sum += Size[i];
            if (zeros > 1)
            {
                sum = 0;
                break;
            }
        }

    printf("%d\n", sum);

    return 0;
}

例题三：

在这里插入图片描述

在这里插入图片描述

思路：

  • 这道题是有点难度的，首先我们得建立这样一个关系
    如图：
    在这里插入图片描述
    这就把题目中的五种关系转换成图的边的关系，从而用图的相关知识点进行解答。

  • 建图之前我们先设置一个超级源点0将各个点相连接起来，边长依旧设置为１，而dist[0] ==0,这样就能保证与超级源点相连接的点的dist[x]=1（也就是能保证后面形成的每个环，这里指的是无前驱的环，最起码环的dist[x]至少为１,保证初始化值的正确性）

  • 这时就用tarjan算法求scc强连通分量,还要统计一下每个scc环的内部节点数量

  • 缩点建立新图，建图的过程中根据题意进行判断，如果其中scc存在边长大于０的正环，那么这题就是无解的，只有这么一种情况才是允许的，环中的边长为０，即每个点的dist[x]是一样的。

  • 在有解的情况下，对scc编号从大到小进行遍历（这时候一定是拓扑序列），然后逐个进行dist[]数组的更新，也就是求按照拓扑序列求每个点到超级源点的最大值（我们不需要求出拓扑序列，因为只要按照scc的编号从大到小进行遍历，那么这就一定是拓扑序列，还有这里是最大值，而不是最小值，切记，切记！！！）如图：
    在这里插入图片描述

代码：

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;

typedef long long LL;

const int N = 100010, M = 600010;

int n, m;
int h[N], hs[N], e[M], ne[M], w[M], idx;
int dfn[N], low[N], timestamp;
int stk[N], top;
bool in_stk[N];
int id[N], scc_cnt, Size[N];
int dist[N];
int in_du[N]={0};

void add(int h[], int a, int b, int c)
{
    e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx ++ ;
    in_du[b]++;
}

void tarjan(int u)
{
    dfn[u] = low[u] = ++ timestamp;
    stk[ ++ top] = u, in_stk[u] = true;

    for (int i = h[u]; ~i; i = ne[i])
    {
        int j = e[i];
        if (!dfn[j])
        {
            tarjan(j);
            low[u] = min(low[u], low[j]);
        }
        else if (in_stk[j]) low[u] = min(low[u], dfn[j]);
    }

    if (dfn[u] == low[u])
    {
        ++ scc_cnt;
        int y;
        do {
            y = stk[top -- ];
            in_stk[y] = false;
            id[y] = scc_cnt;
            Size[scc_cnt] ++ ;
        } while (y != u);
    }
}

int main()
{
    scanf("%d%d", &n, &m);
    memset(h, -1, sizeof h);
    memset(hs, -1, sizeof hs);

   for(int i=1;i<=n;++i) add(h,0,i,1);

    while (m -- )
    {
        int t, a, b;
        scanf("%d%d%d", &t, &a, &b);
        if (t == 1) add(h, b, a, 0), add(h, a, b, 0);
        else if (t == 2) add(h, a, b, 1);
        else if (t == 3) add(h, b, a, 0);
        else if (t == 4) add(h, b, a, 1);
        else add(h, a, b, 0);
    }
    
    //for(int i=1;i<=n;++i) add(h,0,i,1);
    
    

    tarjan(0);

    bool success = true;
    //idx  = 0;
    for (int i = 0; i <= n; i ++ )
    {
        for (int j = h[i]; ~j; j = ne[j])
        {
            int k = e[j];
            int a = id[i], b = id[k];
            if (a == b)
            {
                if (w[j] > 0)
                {
                    success = false;
                    break;
                }
            }
            else add(hs, a, b, w[j]);
        }
        if (!success) break;
    }

    if (!success) puts("-1");
    else
    {
        for (int i = scc_cnt; i; i -- )
        {
            for (int j = hs[i]; ~j; j = ne[j])
            {
                int k = e[j];
                dist[k] = max(dist[k], dist[i] + w[j]);
            }
        }

        LL res = 0;
        for (int i = 1; i <= scc_cnt; i ++ ) res += (LL)dist[i] * Size[i];

        printf("%lld\n", res);
    }

    return 0;
}

猜你喜欢

转载自blog.csdn.net/weixin_43743711/article/details/108697884
今日推荐
基于大语言模型的开源知识库问答系统 MaxKB GitHub Star 数量突破 5,000 个！
美国拟限制 AI 大模型出口中国和俄罗斯
苹果将与 OpenAI 达成协议，将 ChatGPT 应用于 iPhone
openKylin 社区生态委员会第六次会议圆满召开
阿里云正式发布通义千问 2.5
Python 3.13 发布首个 Beta：实验性自由线程模式和 JIT、改进交互式解释器
Stack Overflow 拿我的代码去训练 AI 大模型，还封了我的账号
Pop!_OS 的 COSMIC 桌面完成 App Store 上架工作
《2024 年一季度互联网投融资运行情况》研究报告
报告：Django 仍然是 74% 开发者的首选
15 年前上了“FFmpeg 耻辱柱”，今天他还得谢谢咱——腾讯QQPlayer一雪前耻？
TIOBE 5 月榜单：Fortran “复活”进入 Top 10
周排行
记一下去大梅沙的准备（2018-05-26）
Spring 注解 事务
基于HTTP协议的客户端缓存
阿里云rds 备份和还原
[PHP] 几个拖慢 PHP 程序/API 运行速度的点
python 代码风格------------PEP8规则
js控制json生成菜单——自制菜单（一）
将字符串: 'k:1|k1:2|k2:3|k3:4 ' ,处理成 python 字典: {'k':1, 'k1':2, ...}
微信小程序转支付宝小程序
Qt551.窗口滚动条
每日归档
更多
2024-05-13(18)
2024-05-12(0)
2024-05-11(38)
2024-05-10(38)
2024-05-09(35)
2024-05-08(42)
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)
2024-05-04(7)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022