寒假：Day26

2022-02-06 14:01:37 阅读：198 来源： 互联网

Day26

有向图的强连通分量

在这里插入图片描述

T a r j a n Tarjan Tarjan算法，将一个有向图中的环都缩点，使得这个新图是有向无环图(DAG)，每一个点都属于一个强连通分量中，也就是一个环，最后判断下新图中每一个点的出度，如果只有一个出度为0的点，那么答案就是这个连通分量内的所有点，如果有多个出度为0的点，则答案为0

#include<bits/stdc++.h>
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]); // 更新low值
        }
        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()
{
    cin >> n >> m;
    memset(h, -1, sizeof h);
    while (m -- )
    {
        int a, b;
        cin >> 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; // zeros记录出度为0的连通分量，sum存出度为0的连通分量内的点数
    for (int i = 1; i <= scc_cnt; i ++ ) 
        if (!dout[i])
        {
            zeros ++ ;
            sum += Size[i];
            if (zeros > 1) // 如果有多个出度为0的，那就不存在解
            {
                sum = 0;
                break;
            }
        }

    cout << sum << endl ;
    return 0;
}

1175. 最大半连通子图 - AcWing题库

T a r j a n Tarjan Tarjan 算法应用之求最大弱连通子图及数量，首先强连通必然是弱连通，所以我们先把每一个强连通分量给缩点，缩点后的新图必然是一个有向无环图(拓扑图DAG)，然后我们按照递减顺序找新图中最长的单链(不能有分叉)，那么这条链必然就是最大半连通子图，最后利用递推DP思想即可求出大小及其数量即可

#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
const int N = 100010, M = 2000010;

int n, m, mod;
int h[N], hs[N], e[M], ne[M], idx; // h是旧图，hs是新图
int dfn[N], low[N], timestamp;
int stk[N], top;
bool in_stk[N];
int id[N], scc_cnt, scc_size[N];
int f[N], g[N]; // f记录大小，g记录数量

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

void tarjan(int u) // 利用tarjan算法缩点
{
    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;
            scc_size[scc_cnt] ++ ;
        } while (y != u);
    }
}

int main()
{
    memset(h, -1, sizeof h);
    memset(hs, -1, sizeof hs);
    cin >> n >> m >> mod;
    
    while (m -- )
    {
        int a, b;
        cin >> a >> b;
        add(h, a, b);
    }
    
    for (int i = 1; i <= n; i ++ )
        if (!dfn[i]) tarjan(i);
    
    unordered_set<LL> S;    // 利用哈希把重复边去掉
    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];
            LL hash = a * 1000000ll + b;
            if (a != b && !S.count(hash))
            {
                add(hs, a, b);
                S.insert(hash);
            }
        }
    }
    
    for (int i = scc_cnt; i; i -- ) // 需注意是scc_cnt递减顺序！！
    {
        if (!f[i])
        {
            f[i] = scc_size[i];
            g[i] = 1;
        }
        for (int j = hs[i]; ~j; j = ne[j])
        {
            int k = e[j];
            if (f[k] < f[i] + scc_size[k])
            {
                f[k] = f[i] + scc_size[k];
                g[k] = g[i];
            }
            else if (f[k] == f[i] + scc_size[k])
                g[k] = (g[k] + g[i]) % mod;
        }
    }
    
    int maxf = 0, sum = 0;
    for (int i = 1; i <= scc_cnt; i ++ )
    {
        if (f[i] > maxf)
        {
            maxf = f[i];
            sum = g[i];
        }
        else if (f[i] == maxf) sum = (sum + g[i]) % mod;
    }
    
    cout << maxf << endl << sum << endl ; 
    return 0;
}

标签：连通,int,Day26,scc,stk,++,寒假,low
来源： https://blog.csdn.net/hjh2020012124/article/details/122797647

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9

寒假：Day26

Day26