[JSOI2008]Star War

星球之间互相直接或间接地连接
帝国开始使用死星有计划地摧毁反抗军占领的星球
给出星球间隧道的连通情况，已经帝国打击的顺序
要求以尽量快的速度求出每一次打击之后反抗军占据的星球的联通快的个数（若两个星球，直接或间接的通过现存的通道连接，则视为在一个联通块
输入格式：
第一行两个整数n， m，分别表示星球的数目和隧道的数目
接下来M行，每行两个整数x, y，表示星球x和y之间相连
接下来一个整数k，表示将要被摧毁的星球的数目
接下来k行，每行一个整数，按照顺序列出了帝国军的攻击目标
输出格式：
第一行是开始时星球的联通块个数，接下来k行，每行一个整数，表示经过打击后现存星球的联通块的个数
样例输入
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
2
3
3

我们首先可以想到的是，直接用dfs暴力求连通块会超
很好，那么我们就只有(大概？)一个选择了：并查集维护连通性的同时解决问题
我们发现，题目进行的是删点操作，懂我的意思吧，并查集的维护是合并操作，不是删除操作
然后我们感觉思路有些迷迷糊糊，总感觉要通了，但还是卡的
那就把思考方向换一下。
如果最初默认删掉所有要删的点，然后倒着把要删的点一个一个修回去
很好，求解的答案没有出现差错

最初我们先预求出删掉所有要删的点后，连通块的数量
然后一个一个地往回加点。知道吧所有点加齐
最初预求删完所有点后连通块的数量的同时，将点与点之间父子关系连好
然后修点时再将与要修的点直接相连的点合并在要修的点上，同时维护连通块的数量，记录答案
具体实现和思路代码体会
（保证简单易懂)

 #include<bits/stdc++.h>
 using namespace std;
 const int maxn = ;
 struct enkidu {
     int y, nex, x;
 }e[maxn];
 int lin[maxn], len = ;
 int aim[maxn];//表示要摧毁哪些星球
 int n, m, k;
 int fa[maxn], ans[maxn];
 int vis[maxn];//判断有没有被炸

 inline int read() {
     int x = , y = ;
     char ch = getchar();
     while(!isdigit(ch)) {
         if(ch == '-') y = -;
         ch = getchar();
     }
     while(isdigit(ch)) {
         x = (x << ) + (x << ) +ch - '';
         ch = getchar();
     }
     return x * y;
 }

 inline void insert(int xx, int yy) {
     e[++len].y = yy;
     e[len].x = xx;
     e[len].nex = lin[xx];
     lin[xx] = len;
 }

 int getfather(int x) {
     if(x == fa[x]) return x;
     return fa[x] = getfather(fa[x]);
 }

 int main() {
     memset(lin, -, sizeof(lin));
     n = read(), m = read();
     for(int i = ; i < n; ++i) fa[i] = i;
     for(int i = ; i <= m; ++i) {
         int x, y;
         x = read(), y = read();
         insert(x, y);
         insert(y, x);
     }
     k = read();
     int num = n - k;//k次打击后，还剩下点的数量
     for(int i = ; i <= k; ++i) {
         int star;
         star = read();
         vis[star] = ;
         aim[i] = star;
     }
     for(int i = ; i <=  * m; ++i) {
         int x = e[i].x, y = e[i].y;
         if(!vis[x] && !vis[y]) {
             int u = getfather(x);
             int v = getfather(y);
             if(u != v) {//计算打击了k次后的连通块数量
                 num--;//表示有一对没有搜过的点连通，连通块数量减一
                 fa[v] = fa[u];
             }
         }
     }
     ans[k + ] = num;//k次打击后剩的连通块数量
     //cout << num << '\n';
     for(int i = k; i >= ; --i) {
         num++;
         int force = aim[i];
         vis[force] = ;
         //cout << num << '\n';
         int u = getfather(force);
         //cout << u << '\n';
         for(int j = lin[force]; j != -; j = e[j].nex) {
             //cout << j << '\n';
             int to = e[j].y;
             if(!vis[to]) {
                 int v = getfather(to);
                 if(u != v) {
                     num--;
                     fa[v] = u;
                 }
             }
         }
         ans[i] = num;
     }
     for(int i = ; i <= k + ; ++i)
         cout << ans[i] << '\n';
     return ;
 }