HDU 3836 Equivalent Sets【Tarjan染色+搭桥】

Equivalent Sets

Time Limit: 12000/4000 MS (Java/Others) Memory Limit: 104857/104857 K (Java/Others)
Total Submission(s): 3394 Accepted Submission(s): 1170

Problem Description
To prove two sets A and B are equivalent, we can first prove A is a subset of B, and then prove B is a subset of A, so finally we got that these two sets are equivalent.
You are to prove N sets are equivalent, using the method above: in each step you can prove a set X is a subset of another set Y, and there are also some sets that are already proven to be subsets of some other sets.
Now you want to know the minimum steps needed to get the problem proved.

Input
The input file contains multiple test cases, in each case, the first line contains two integers N <= 20000 and M <= 50000.
Next M lines, each line contains two integers X, Y, means set X in a subset of set Y.

Output
For each case, output a single integer: the minimum steps needed.

Sample Input
4 0 3 2 1 2 1 3

Sample Output
4 2
Hint
Case 2: First prove set 2 is a subset of set 1 and then prove set 3 is a subset of set 1.

题意：n个点m条边的有向图，问最少增加多少边使之变成一个强连通图；
分析：Tarjan预处理缩点染色后，就是一个或多个有向图，然后你可以进行图的一系列操作；
本题构造scc，图的首部和尾部连起来即可，如果有首部和尾部都有多个，画图看一下就清晰了，统计入度和出度为0的个数最大值；

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
#include <vector>
using namespace std;
typedef long long LL;

const int MAXN = 50010;
int stack[MAXN], col[MAXN], vis[MAXN];
int dfn[MAXN], low[MAXN], in[MAXN], out[MAXN];
int index, top, scc;
vector<int> V[MAXN];

void init() {
    memset(dfn, 0, sizeof(dfn));
    memset(vis, 0, sizeof(vis));
    memset(out, 0, sizeof(out));
    memset(in, 0, sizeof(in));
    index = scc = top = 0;
    for(int i = 0; i < MAXN; i++) {
        V[i].clear();
    }
}

inline void tarjan(int u) {
    int v;
    low[u] = dfn[u] = ++index;
    stack[top++] = u;
    vis[u] = 1;
    for(int i = 0; i < V[u].size(); ++i) {
        v = V[u][i];
        if(!dfn[v]) {
            tarjan(v);
            low[u] = min(low[v], low[u]);
        }
        else if(vis[v] && low[u] > dfn[v]) {
            low[u] = dfn[v];
        }
    }
    if(low[u] == dfn[u]) {
        scc++;
        do {
            v = stack[--top];
            vis[v] = 0;
            col[v] = scc;
        } while(v != u);
    }
}

void solve(int n) {
    for(int i = 1; i <= n; ++i) {
        if(!dfn[i]) {
            tarjan(i);
        }
    }
    if(scc == 1) {
        printf("0\n");
        return ;
    }
    memset(vis, 0, sizeof(vis));
    for(int i = 1; i <= n; ++i) {
        for(int j = 0; j < V[i].size(); ++j) {
            int v = V[i][j];
            if(col[v] == col[i]) continue;
            in[col[v]]++;
            out[col[i]]++;
        }
    }
    int ans1 = 0, ans2 = 0;
    for(int i = 1; i <= scc; ++i) {
        if(!out[i]) ans1++;
        if(!in[i]) ans2++;
    }
    printf("%d\n", max(ans1, ans2));
}

int main() {
    int n, m, A, B;
    while(scanf("%d %d", &n, &m) != EOF) {
        init();
        while(m--) {
            scanf("%d %d", &A, &B);
            V[A].push_back(B);
        }
        solve(n);
    }
    return 0;
}