D-City

D-City
Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 65535/65535 K (Java/Others)
Total Submission(s): 18 Accepted Submission(s): 15

Problem Description
Luxer is a really bad guy. He destroys everything he met.
One day Luxer went to D-city. D-city has N D-points and M D-lines. Each D-line connects exactly two D-points. Luxer will destroy all the D-lines. The mayor of D-city wants to know how many connected blocks of D-city left after Luxer destroying the first K D-lines in the input.
Two points are in the same connected blocks if and only if they connect to each other directly or indirectly.

Input
First line of the input contains two integers N and M.
Then following M lines each containing 2 space-separated integers u and v, which denotes an D-line.
Constraints:
0 < N <= 10000
0 < M <= 100000
0 <= u, v < N.

Output
Output M lines, the ith line is the answer after deleting the first i edges in the input.

Sample Input
5 10 0 1 1 2 1 3 1 4 0 2 2 3 0 4 0 3 3 4 2 4

Sample Output
1 1 1 2 2 2 2 3 4 5
Hint
The graph given in sample input is a complete graph, that each pair of vertex has an edge connecting them, so there’s only 1 connected block at first. The first 3 lines of output are 1s because after deleting the first 3 edges of the graph, all vertexes still connected together. But after deleting the first 4 edges of the graph, vertex 1 will be disconnected with other vertex, and it became an independent connected block. Continue deleting edges the disconnected blocks increased and finally it will became the number of vertex, so the last output should always be N.

给定一张无向图，有 n 个节点和 m 条边。问删掉前 i 条边后，该无向图中还剩下多少连通块。
输入
（多组输入）

第一行输入 n,m 表示有 n 个节点， m 条边。之后有 m 行，其中第 m_i 行表明无向图的边所连的两个节点。
0 < N <= 10000
0 < M <= 100000

Output
输出 m 行，第 m_i 行表明删掉前 i 条边后，无向图中有多少连通块
Sample Input
5 10
0 1
1 2
1 3
1 4
0 2
2 3
0 4
0 3
3 4
2 4
Sample Output
1
1
1
2
2
2
2
3
4
5

解题思路：
我们可以将这些数据存起来，并且从最后来进行合并，并且记下合并每一组后他又多少个连通块，这样就可以很简单的解决这个问题，所以来上代码

#include <iostream>
#include <cstdio>
#include <cstring>

using namespace std;

const int maxn = 10010;
int fa[maxn];//标记每个节点的祖先，如果为-1祖先就是自己
int ans[100010];//存储每组数据合并后有多少个联通块
pair<int,int> p[100010];//存储每组数据

int fund(int a){
	if(fa[a] == -1) return a;
	else return fa[a] = fund(fa[a]);
}

int main () {
	int n,m;
	while(scanf("%d %d",&n,&m) != EOF) {
		memset(fa,-1,sizeof(fa));//初始化数组
		for(int i = 1;i <= m;i++)
			scanf("%d %d",&p[i].first,&p[i].second);
		ans[m] = n;//最后一组数据的连通块为n
		for(int i = m;i > 1;i--) {
			int x = fund(p[i].first);
			int y = fund(p[i].second);
			if(x != y) {
				ans[i-1] = ans[i] - 1;//每连一组数据如果连接成功就减少一个连通块
				fa[x] = y;
			}
			else
				ans[i-1] = ans[i];//如果之前就已经连通成功，就还是之前的值
		}
		for(int i = 1;i <= m;i++)
			printf("%d\n",ans[i]);//直接输出答案
	}
	return 0;
}