寒假：Day26

Day26

有向图的强连通分量

1174. 受欢迎的牛 - AcWing题库

$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题库

$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;
}