#洛谷 P1197 [JSOI2008]星球大战 （离线 + 并查集）

题目描述

很久以前，在一个遥远的星系，一个黑暗的帝国靠着它的超级武器统治着整个星系。

某一天，凭着一个偶然的机遇，一支反抗军摧毁了帝国的超级武器，并攻下了星系中几乎所有的星球。这些星球通过特殊的以太隧道互相直接或间接地连接。

但好景不长，很快帝国又重新造出了他的超级武器。凭借这超级武器的力量，帝国开始有计划地摧毁反抗军占领的星球。由于星球的不断被摧毁，两个星球之间的通讯通道也开始不可靠起来。

现在，反抗军首领交给你一个任务：给出原来两个星球之间的以太隧道连通情况以及帝国打击的星球顺序，以尽量快的速度求出每一次打击之后反抗军占据的星球的连通块的个数。（如果两个星球可以通过现存的以太通道直接或间接地连通，则这两个星球在同一个连通块中）。

输入格式

输入文件第一行包含两个整数，NNN (1<=N<=2M1 < = N < = 2M1<=N<=2M) 和 MMM (1<=M<=200,0001 < = M < = 200,0001<=M<=200,000)，分别表示星球的数目和以太隧道的数目。星球用 000 ~ N−1N-1N−1 的整数编号。

接下来的 MMM 行，每行包括两个整数 XXX, YYY，其中（ 0<=X<>Y0 < = X <> Y0<=X<>Y 表示星球 xxx 和星球 yyy 之间有 “以太” 隧道，可以直接通讯。

接下来的一行为一个整数 kkk ，表示将遭受攻击的星球的数目。

接下来的 kkk 行，每行有一个整数，按照顺序列出了帝国军的攻击目标。这 kkk 个数互不相同，且都在 000 到 n−1n-1n−1 的范围内。

输出格式

第一行是开始时星球的连通块个数。接下来的 KKK 行，每行一个整数，表示经过该次打击后现存星球的连通块个数。

输入输出样例

输入 #1复制

8 13
0 1
1 6
6 5
5 0
0 6
1 2
2 3
3 4
4 5
7 1
7 2
7 6
3 6
5
1
6
3
5
7

输出 #1复制

1
1
1
2
3
3

说明/提示

[JSOI2008]

题目大意 ： 输入一个无向图， 每次删去一个点， 问还有多少个连通块

思路 ：并查集的作用是连边， 但是本题要求是删边，咋办，离线倒着来呗。首先将所有删的点标记，剩下未标记的点的个数就是最后一次的连通块的最大可能情况，然后遍历每个点，看他所连接的点是否标记了，如果未标记，那连通块数量减一，因为两个独立的点相连嘛， 遍历完最后一个点删除后的连通块就处理好了。其他的点和这个一样，每次把删去的一个点加回来就多一个连通块，然后有多少个于他相连并且还没加入的点，就减去多少个连通块，画画图就明白了

Accepted code

#include<bits/stdc++.h>
#include<unordered_map>
using namespace std;

#define sc scanf
#define ls rt << 1
#define rs ls | 1
#define Min(x, y) x = min(x, y)
#define Max(x, y) x = max(x, y)
#define ALL(x) (x).begin(),(x).end()
#define SZ(x) ((int)(x).size())
#define MEM(x, b) memset(x, b, sizeof(x))
#define lowbit(x) ((x) & -(x))
#define P2(x) ((x) * (x))

typedef long long ll;
const int MOD = 1e9 + 7;
const int MAXN = 2e6 + 100;
const int INF = 0x3f3f3f3f;
inline ll fpow(ll a, ll b){ ll r = 1, t = a; while (b){ if (b & 1)r = (r*t) % MOD; b >>= 1; t = (t*t) % MOD; }return r; }

struct Edge
{
	int v, next;
}e[MAXN << 1];
int head[MAXN], p[MAXN], n, m, k, cnt, ans;
int line[MAXN], q[MAXN], X;
bool vis[MAXN];
void init() {
	MEM(head, -1);
	for (int i = 0; i < n; i++) p[i] = i;
}
void add(int from, int to) {
	e[++cnt].v = to;
	e[cnt].next = head[from];
	head[from] = cnt;
}
int find_(int x) {
	while (x != p[x]) x = p[x] = p[p[x]];
	return x;
}
void unite(int x, int y) {
	x = find_(x);
	y = find_(y);
	if (x != y) p[x] = y;
}

int main()
{
	cin >> n >> m; init();
	for (int i = 0; i < m; i++) {
		int ui, vi;
		sc("%d %d", &ui, &vi);
		add(ui, vi); add(vi, ui);
	}
	cin >> k;
	for (int i = 0; i < k; i++) {
		sc("%d", &q[i]); 
		vis[q[i]] = true;
	}
	ans = n - k;  // 最大连通块数
	for (int i = 0; i < n; i++) {
		if (vis[i]) continue;
		for (int j = head[i]; j != -1; j = e[j].next) {
			int vi = e[j].v;
			if (find_(vi) != find_(i) && !vis[vi]) unite(i, vi), ans--;
		}
	}
	line[X++] = ans;
	for (int i = k - 1; i >= 0; i--) {
		int x = q[i]; vis[x] = false;
		ans++;
		for (int j = head[x]; j != -1; j = e[j].next) {
			int vi = e[j].v;
			if (vis[vi]) continue; 
			if (find_(x) != find_(vi)) ans--, unite(x, vi);
		}
		line[X++] = ans;
	}
	for (int i = X - 1; i >= 0; i--) cout << line[i] << endl;
	return 0;
}