BZOJ [JSOI2008]星球大战starwar

链接：P1015

Description
　　很久以前，在一个遥远的星系，一个黑暗的帝国靠着它的超级武器统治者整个星系。某一天，凭着一个偶然的
机遇，一支反抗军摧毁了帝国的超级武器，并攻下了星系中几乎所有的星球。这些星球通过特殊的以太隧道互相直
接或间接地连接。 但好景不长，很快帝国又重新造出了他的超级武器。凭借这超级武器的力量，帝国开始有计划
地摧毁反抗军占领的星球。由于星球的不断被摧毁，两个星球之间的通讯通道也开始不可靠起来。现在，反抗军首
领交给你一个任务：给出原来两个星球之间的以太隧道连通情况以及帝国打击的星球顺序，以尽量快的速度求出每
一次打击之后反抗军占据的星球的连通快的个数。（如果两个星球可以通过现存的以太通道直接或间接地连通，则
这两个星球在同一个连通块中）。

Input
　　输入文件第一行包含两个整数，N (1 < = N < = 2M) 和M (1 < = M < = 200,000)，分别表示星球的
数目和以太隧道的数目。星球用 0 ~ N-1的整数编号。接下来的M行，每行包括两个整数X, Y，其中（0 < = X <>
Y 表示星球x和星球y之间有“以太”隧道，可以直接通讯。接下来的一行为一个整数k，表示将遭受攻击的星球的
数目。接下来的k行，每行有一个整数，按照顺序列出了帝国军的攻击目标。这k个数互不相同，且都在0到n-1的范
围内。

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

Sample Input
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
Sample Output
1
1
1
2
3
3

---

嗯，一遇到这种连通性的问题首先我想到的就是并查集
但是这里我们需要了解一下求连通块的一种方式：

设连通块有ans个
我们可以先初始化所有n个点都没有连通，那么连通块的个数就是有ans=n个
那么我们已经删去了t个点，那么连通块最多也就只有ans=n-t个了（那t个点不存在了，那么如果剩下的点都不连通就是最多的情况）
然后我们在并查集中进行合并操作中，就说明这两个点可以连成一个连通块。
因为初始化这两个点是单独两个连通块，现在合并了就变成了一个连通块，则ans-1即可

Part1
我们有一种纯暴力的思路，就是我们删除一个点，从头合并一次，删除一个点再合并一次。这样的思路时间复杂度将近在O(N(v+e)lgn)对于大数据有一点无法承受。
这种思路可以得到30分左右的

放一下代码吧：

#include <cstdio>
#include <iostream>
using namespace std;
int a[400001][3],fa[400001],n,m,ans,b[400001],w[400001],t,k[400001];
int find(int x)
{
	if (x==fa[x])
	return x;
	fa[x]=find(fa[x]);
	return fa[x];
} //并查集路径压缩
void he(int x,int y)
{
	int x1=find(x),x2=find(y);
	if (x1!=x2)
	{
		fa[x2]=x1;
		ans--;
	}
}
void sc()
{
	for (int i=0;i<=n;i++)
	fa[i]=i;
	return ;
}
int main()
{
	scanf("%d%d",&n,&m);
	for (int i=0;i<=n;i++)
	fa[i]=i;
	for (int i=1;i<=m;i++)
	{
	   int x,y;
	   scanf("%d%d",&a[i][0],&a[i][1]);
}
scanf("%d",&t);
ans=n-t;
	for (int i=1;i<=t;i++)
	{
		scanf("%d",&w[i]);
		b[w[i]]=1;
	}
	sc();
	for (int j=1;j<=m;j++)
	{
		if (b[a[j][0]]==0 && b[a[j][1]]==0)
		he(a[j][0],a[j][1]);
	}   
	k[t+1]=ans;
	for (int i=t;i>=1;i--)
	{
		b[w[i]]=0;
	ans++;
		for (int j=1;j<=m;j++)
		if (b[a[j][0]]==0 && b[a[j][1]]==0)
		he(a[j][0],a[j][1]);
		k[i]=ans;
	}   //被每一次去除的点都
	for (int i=1;i<=t+1;i++)
	printf("%d\n",k[i]);
	
	return 0;
}

Part2
这种做法我们需要转化，不能硬着头皮做
如果我们按照每次去除的点来做会大量超时，那么我们可以转化为每次建造点
我们反过来做，从最终去完点之后的时候结果来看，先把最后没有删去的点全部连通，再求此时的连通块即为最后一行的答案，然后我们再往前走把删去的这个点与其相连的点合并起来，则是删去这个点之前的连通块个数

代码

#include <cstdio>
#include <iostream>
using namespace std;
int fa[400001],n,m,ans,b[400001],w[400001],t,k[400001],h[400001],top;
struct CZP
{
	int next,from,to;
}a[400001];
void cun(int from,int to)
{
	a[++top].next=h[from];
	a[top].to=to;
	a[top].from=from;
	h[from]=top;
}  //邻接表存储
int find(int x)
{
	if (x==fa[x])
	return x;
	fa[x]=find(fa[x]);
	return fa[x];
}  //并查集路径压缩
void he(int x,int y)
{
	int x1=find(x),x2=find(y);
	if (x1!=x2)
	{
		fa[x2]=x1;
		ans--;  //连通块个数减一
	}
}  //并查集合并操作
void sc()
{
	for (int i=0;i<=n;i++)
	fa[i]=i;
	return ;
}  //初始化并查集
int main()
{
	scanf("%d%d",&n,&m);
	for (int i=0;i<=n;i++)
	fa[i]=i,h[i]=-1;
	for (int i=1;i<=m;i++)
	{
	   int x,y;
	   scanf("%d%d",&x,&y);
	   cun(x,y);
	   cun(y,x);
}
scanf("%d",&t);
ans=n-t;
	for (int i=1;i<=t;i++)
	{
		scanf("%d",&w[i]);
		b[w[i]]=1;
	}
	sc();
	for (int j=1;j<=2*m;j++)
	{
		if (b[a[j].to]==0 && b[a[j].from]==0)
		he(a[j].from,a[j].to);
	}  //先把全部删完后的剩下没删的点能连成的连起来
	k[t+1]=ans;  //这个就是删完要求最后一个点后的连通块个数
	for (int i=t;i>=1;i--)
	{
		b[w[i]]=0;
     	ans++;
     	int j=h[w[i]];
     	while (j!=-1)
     	{
		if (b[a[j].to]==0 && b[a[j].from]==0)
		he(a[j].from,a[j].to);
		j=a[j].next;
	}  //合并当前要删除的点与其可以相连的点
		k[i]=ans;  //这个就是删除这个点之前的连通块个数
	}
	
	for (int i=1;i<=t+1;i++)
	printf("%d\n",k[i]);
	return 0;
}