hdu4635 Strongly connected（tarjan+缩点后入度出度）

题意：

给定一个 n 个节点，m 条边的有向图，求最大可以增加多少条边使得这个有向图仍然不是强连通。 

思路：

可以把图分为两部分，x和y，x、y图是强连通图，xy之间的边的方向是一致的，全是x的点到y的点或y到x，这样才能使边最多。设x的点为a个，则x图的边最多a*(a-1)个，y也一样是b*(b-1)，xy之间的边最多x*y个，ans=a*(a-1)+b*(b-1)-x*y-m=n*n-n-x*y-m，使x*y最小的是答案。所以可以用tarjan缩点后计算每个强连通分量的入度出度，入度或出度为0的强连通分量可以作为x或y的一个使用，所以找一个入度或出度为0的最小的强连通分量作为x就是答案。

#include<bits/stdc++.h>
#define ll long long
using namespace std;
const int N = 1e5 + 10;
int n, m, t, h[N], cnt;
int inde, dfn[N], low[N], scc[N], ins[N], sum, in[N], out[N];
stack<int> s;
struct node {
    int v, net;
} no[N];
void add(int u, int v) {
    no[cnt].v = v;
    no[cnt].net = h[u];
    h[u] = cnt++;
}
void init() {
    sum = cnt = inde = 0;
    memset(dfn, 0, sizeof dfn);
    memset(h, -1, sizeof h);
    memset(ins, 0, sizeof ins);
    memset(in, 0, sizeof in);
    memset(out, 0, sizeof out);
}
void tarjan(int u) {
    dfn[u] = low[u] = ++inde;
    ins[u] = 1;
    s.push(u);
    for(int i = h[u]; ~i; i = no[i].net) {
        int v = no[i].v;
        if(!dfn[v]) {
            tarjan(v);
            low[u] = min(low[v], low[u]);
        } else if(ins[v])
            low[u] = min(low[u], dfn[v]);
    }
    if(low[u] == dfn[u]) {
        sum++;
        while(s.top() != u) {
            int v = s.top();
            scc[v] = sum, ins[v] = 0;
            s.pop();
        }
        s.pop();
        ins[u] = 0, scc[u] = sum;
    }
}
int main() {
    cin >> t;
    int test = 0;
    while(t--) {
        init();
        cin >> n >> m;
        for(int x, y, i = 0; i < m; i++) {
            cin >> x >> y;
            add(x, y);
        }
        for(int i = 1; i <= n; i++)
            if(!dfn[i])
                tarjan(i);
        if(sum == 1) {
            cout << "Case " << ++test << ": " << -1 << endl;
            continue;
        }
        ll ans = n * n - n - m, mi = 100001;
        for(int k = 1; k <= n; k++)//计算强连通分量的入度出度
            for(int i = h[k]; ~i; i = no[i].net) {
                int v = no[i].v;
                if(scc[k] != scc[v])//不属于同一分量
                    in[scc[v]]++, out[scc[k]]++;
            }
        for(int i = 1; i <= sum; i++) {
            if(in[i] && out[i])
                continue;
            ll ss = 0;
            for(int j = 1; j <= n; j++)
                if(scc[j] == i)
                    ss++;
            mi = min(mi, ss);
        }
        ans -= (mi * (n - mi));
        cout << "Case " << ++test << ": " << ans << endl;
    }
    return 0;
}