HDU 4635 Strongly connected （强连通分量+缩点）

题意：给出一张简单图，问最多加多少边让这张图还是简单图（无重边，无自环），且不是强连通图。

题解：强连通分量+缩点
若最后的图仍不是强连通的，且要边最多，那么他一定由两个强连通分量构成。

首先我们明确一点，边数最多的简单图是完全图，若边有向，则边数为$n\ast (n-1)$。

假设一个强连通分量有$x$个点，另一个分量有$y$个点，$x+y=n$
我们要让边数最多，则两个分量必定都是完全图，且两个分量间只有单向边。
由此我们可得：
第一个分量边数：$x\ast (x-1)$
第二个分量边数：$y\ast (y-1)$
由于两分量间只有单向边，则单向边最多为：$x\ast y$
所以最后我们得到的总边数就是：$x\ast (x-1)+y\ast (y-1)+x\ast y$
化简后得：$n\ast n-n-x\ast y$

由于我们要让该值最大，则$x\ast y$一定要最小，即$x$或$y$最小。
所以我们只要找到出度或入度为0，且点数最小的分量即可，答案也就出来了，记得减去原来的m条边。

代码直接求的总量最大，或者按上面讲的先求最小$x$也可。

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<cstdio>
#include<string>
#include<cstring>
#include<algorithm>
#include<queue>
#include<stack>
#include<cmath>
#include<vector>
#include<fstream>
#include<set>
#include<map>
#include<sstream>
#include<iomanip>
#define ll long long
using namespace std;
/*
 * Tarjan 算法
 * 复杂度 O(N+M)
 */
const int MAXN = 100010;//点数
const int MAXM = 100010;//边数
struct Edge {
    int to, next;
}edge[MAXM];
int head[MAXN], tot;
//DFN：深度优先搜索遍历时结点u被搜索的次序
int Low[MAXN], DFN[MAXN], Stack[MAXN], Belong[MAXN];//Belong 数组的值是1 ~ scc
int Index, top;
int scc;//强连通分量的个数
bool Instack[MAXN];
int num[MAXN];//各个强连通分量包含点的个数，数组编号 1 ∼ scc
//num 数组不一定需要，结合实际情况

void addedge(int u, int v) {
    edge[tot].to = v; edge[tot].next = head[u]; head[u] = tot++;
}
void Tarjan(int u) {
    int v;
    Low[u] = DFN[u] = ++Index;
    Stack[top++] = u;
    Instack[u] = true;
    for (int i = head[u]; i != -1; i = edge[i].next) {
        v = edge[i].to;
        if (!DFN[v]) {
            Tarjan(v);
            if (Low[u] > Low[v]) Low[u] = Low[v];
        }
        else if (Instack[v] && Low[u] > DFN[v]) Low[u] = DFN[v];
    }
    if (Low[u] == DFN[u]) {
        scc++;
        do {
            v = Stack[--top];
            Instack[v] = false;
            Belong[v] = scc;
            num[scc]++;
        } while (v != u);
    }
}
void solve(int N) {
    memset(DFN, 0, sizeof(DFN));
    memset(Instack, false, sizeof(Instack));
    memset(num, 0, sizeof(num));
    Index = scc = top = 0;
    for (int i = 1; i <= N; i++)
        if (!DFN[i]) Tarjan(i);
}
void init() {
    tot = 0;
    memset(head, -1, sizeof(head));
}
int t, n, m, u, v, in[MAXN], out[MAXN];
int main() {
	scanf("%d", &t);
	int cas = 0;
	while (t--) {
        init();
        memset(in, 0, sizeof(in));
        memset(out, 0, sizeof(out));
		scanf("%d%d", &n, &m);
		for (int i = 1; i <= m; i++) {
			scanf("%d%d", &u, &v);
            addedge(u, v);
		}
        solve(n);
        for (int i = 1; i <= n; i++) {
            for (int j = head[i]; ~j; j = edge[j].next) {
                int v = edge[j].to;
                if (Belong[i] != Belong[v]) {
                    in[Belong[v]] = 1;
                    out[Belong[i]] = 1;
                }
            }
        }
        int ans = 0;
        for (int i = 1; i <= scc; i++) {
            if (in[i] == 0 || out[i] == 0) {
                int k = num[i];
                ans = max(ans, k * (k - 1) + (n - k) * (n - k - 1) + k * (n - k) - m);
            }
        }
        printf("Case %d: %d\n", ++cas, scc == 1 ? -1 : ans);
	}
	return 0;
}