JOISC2020 DAY2T2 （LOJ#3275. 「JOISC 2020 Day2」有趣的 Joitter 交友）（启发式合并 + 计数）

JOISC2020 DAY2T2

首先注意到可以把有双向边的点对缩起来。

那么当前形成的这个有向图没有一对点之间有双向边。

然后考虑一条边$(x,y)$的贡献就是$Siz{e}_y$（即$y$所在块的大小）。一个块$x$内部的贡献是$siz{e}_x(siz{e}_x-1)$。

我们记$e[x][y]$表示$x$这个联通块连向$y$这个联通块的边数。两个块$a,b$合并时的贡献就可以算出。

现在考虑合并两个块$a,b$（把$a$合并到$b$中）。

那么首先要把$e[a]$与$e[b]$合并。然后再考虑枚举$a$的每条出边以及$a$的每条入边，把它们复制到$b$上。

当合并的时候原本连向$a$的每条边这个时候可能会有一个$siz{e}_b$的贡献（决定于它之前有没有连向$a$），同理连向$b$的每条边也如此。

但注意到不能枚举$b$的出边及入边，所以要额外记录一个$Su{m}_x$表示$x$这个块的总入度之和。

此时还要看看$a,b$联通之后有哪些块可以继续合并，递归处理即可。

时间复杂度$O(nlo{g}^{2}n)$。

#pragma GCC optimize(3, "Ofast", "inline")
#include 

#define F(i, a, b) for (int i = a; i <= b; i ++)
#define G(i, a, b) for (int i = a; i >= b; i --)
#define outarr(a, L, R) { printf(#a"[%d..%d] = ", L, R); F(i, L, R) W(a[i]), putc(' '); putc('\n'); }
#define out3(x, y, z) { printf(#x" = "), W(x), printf("  "#y" = "), W(y); printf("  "#z" = "), W(z); putc('\n'); }
#define out2(x, y) { printf(#x" = "), W(x), printf("  "#y" = "), W(y); putc('\n'); }
#define outline() { puts("--------------------------------------------------"); }
#define out1(x) { printf(#x" = "); W(x), putc('\n'); }
#define max(a, b) ((a) > (b) ? (a) : (b))
#define min(a, b) ((a) < (b) ? (a) : (b)) 
#define mem(a, b) memset(a, b, sizeof a)
#define mec(a, b) memcpy(a, b, sizeof a)
#define mx(a, b) ((a) = max(a, b))
#define mn(a, b) ((a) = min(a, b))
#define low(x) ((x) & (- (x)))
#define abs(x) (max(x, - (x)))
#define sqr(x) ((x) * (x))
#define get getchar()
#define pb push_back
#define putc putchar

using namespace std;

template <typename Int>
void R(Int &x) {
     
	char c = get; x = 0; Int t = 1;
	for (; !isdigit(c); c = get) t = (c == '-' ? - 1 : t);
	for (; isdigit(c); x = (x << 3) + (x << 1) + c - '0', c = get); x *= t;
}
template <typename Int>
void W(Int x) {
     
	if (x < 0) {
      putc('-'); x = - x; }
	if (x > 9) W(x / 10); putc(x % 10 + '0');
}

const int N = 1e5 + 10;
int n, m, a, b, SZ, fa[N], Sum[N];
map <int, int> e[N]; set <int> in[N], ou[N];
long long Ans, sz[N];

int FA(int x) {
      return !fa[x] ? x : fa[x] = FA(fa[x]); }

void Merge(int a, int b) {
     
	a = FA(a), b = FA(b);
	if (a == b) return;
	Ans += (2 * sz[a] * sz[b]) - (e[a][b] * sz[b] + e[b][a] * sz[a]);
	if (ou[a].size() + in[a].size() + sz[a] > ou[b].size() + in[b].size() + sz[b])
		swap(a, b);
	Sum[b] -= e[a][b];
	fa[a] = b;
	sz[b] += sz[a];
	vector <int> vec; vec.clear();
	Ans += Sum[b] * sz[a];
	for (multiset <int> :: iterator it = ou[a].begin(); it != ou[a].end(); it ++) {
     
		int x = *it, c = FA(x);
		if (c == b) continue;
		if (e[c][b]) vec.push_back(c);
		ou[b].insert(x);
	}
	for (map <int, int> :: iterator it = e[a].begin(); it != e[a].end(); it ++) {
     
		int c = (*it).first;
		e[b][c] += e[a][c];
	}
	for (multiset <int> :: iterator it = in[a].begin(); it != in[a].end(); it ++) {
     
	  	int x = *it, c = FA(x);
		if (c == b) continue;
		if (e[b][c]) vec.push_back(c);
		if (in[b].find(x) == in[b].end()) {
     
			in[b].insert(x);
			Ans += sz[b] - sz[a];
			e[c][b] ++;
			Sum[b] ++;
		}
		else
			Ans -= sz[a];
		ou[c].insert(b);
	}
	int SIZE = vec.size() - 1;
	F(i, 0, SIZE) Merge(b, vec[i]); 
}

int main() {
     
	R(n), R(m);
	F(i, 1, n) sz[i] = 1;
	F(i, 1, m) {
     
		R(a), R(b); int A = a, B = b;
		a = FA(a), b = FA(b);
		if (a != b) {
     
			if (in[b].find(A) == in[b].end())
				in[b].insert(A), e[a][b] ++, Ans += sz[b], Sum[b] ++;
			if (ou[a].find(B) == ou[a].end())
				ou[a].insert(B);
			if (e[b][a])
				Merge(a, b);
		}
		W(Ans), putc('\n');
	}
}