洛谷P1197 星球大战

题目描述

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

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

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

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

输入格式

输入文件第一行包含两个整数，n,mn,m，分别表示星球的数目和以太隧道的数目。星球用 0 \sim n-10∼n−1 的整数编号。

接下来的 mm 行，每行包括两个整数 x,yx,y，表示星球 xx 和星球 yy 之间有 “以太” 隧道，可以直接通讯。

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

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

输出格式

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

输入输出样例

输入 #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

说明/提示

【数据范围】
对于 100\%100% 的数据，1\le m \le 2\times 10^51≤m≤2×105，1\le n \le 2m1≤n≤2m，x \neq yx=y。

上代码：

#include<iostream>
#include<cstdio>
#define f(i,a,b) for(register int i=a;i<=b;i++)
#define fd(i,a,b) for(register int i=a;i>=b;i--)
using namespace std;
int k,n,m,head[400002],tot,broken[400002],ans[400003];
int father[400003];
struct Node
{
    int next,node,from;
}h[400002];
inline void Add_Node(int u,int v)
{
    h[++tot].from=u;
    h[tot].next=head[u];
    head[u]=tot;
    h[tot].node=v;
}
bool Broken[400001];
inline int Get_father(int x)
{
    if(father[x]==x)    return x;
    return father[x]=Get_father(father[x]);
    //你爸爸的爸爸就是你的爸爸——反查理马特——并查集 
}
inline void hb(int u,int v)
{
    u=Get_father(u),v=Get_father(v);
    if(u!=v)    father[v]=u;
}
int main()
{
    ios::sync_with_stdio(false);
    cin>>n>>m;
    f(i,0,n)
        father[i]=i,head[i]=-1;//并查集初始化 
    f(i,1,m)
    {
        int x,y;
        cin>>x>>y;
        Add_Node(x,y);//储存图 
        Add_Node(y,x);//由于无向图存两遍 
    }
    cin>>k;
    f(i,1,k)
    {
        cin>>broken[i];
        Broken[broken[i]]=1;//标记砸坏了 
    }
    int total=n-k;//初始化为所有点都是单独存在的 
    f(i,1,2*m)//有2*m个边 
        if(!Broken[h[i].from] && !Broken[h[i].node] && Get_father(h[i].from)!=Get_father(h[i].node))
		{//要是起点和终点都没砸坏 而且他们并没有联通
            total--;//连一条边 减一个联通体 
            hb(h[i].from,h[i].node);
        }
    ans[k+1]=total;//当前就是最后一次破坏后的个数 
    fd(i,k,1)
    {
        //total=0 //这里不需要初始化 需要从上一次的废墟上修建 
        total++;//修复一个点 联通体+1 
        Broken[broken[i]]=0;//修复 
        for(int j=head[broken[i]];j!=-1;j=h[j].next)//枚举每一个子点 
        {
            if(!Broken[h[j].node] && Get_father(broken[i])!=Get_father(h[j].node))
            {
                total--;//连一边减一个联通块 
                hb(broken[i],h[j].node);//合并这两个点 
            }
        }
        ans[i]=total;
    }
    f(i,1,k+1)    cout<<ans[i]<<endl;
    return 0;
}