P1197 星球大战(并查集+链式向前星)

#include<iostream>
using namespace std;
const int N=4e5+100;
struct edge
{
    int from;
    int to;
    int nex;
};
edge a[N];
int head[N];
int cnt=0;
//以上是链式向前星存储图
int fa[N];//并查集
bool used[N];//每个点是否被摧毁
int node[N];//被摧毁的
int ans[N];//答案
void init(int n)
{
    for(int i=0;i<n;i++)
    {
        fa[i]=i;//并查集
        used[i]=0;
        head[i]=-1;
    }
}
void add(int b,int c)//边的计数从0开始
{
    a[cnt].from=b;
    a[cnt].to=c;
    a[cnt].nex=head[b];
    head[b]=cnt;
    cnt++;
}
int finds(int x)
{
    while(fa[x]!=fa[fa[x]])
    {
        fa[x]=fa[fa[x]];
    }
    return fa[x];
}
int main(void)
{
    int n,m;
    cin>>n>>m;
    init(n);//初始化
    for(int i=1;i<=m;i++)
    {
        int a,b;
        cin>>a>>b;
        add(a,b);//无向图
        add(b,a);
    }
    int k;
    cin>>k;
    for(int i=0;i<k;i++)//被摧毁的顺序，反过来就是重建的顺序
    {
        cin>>node[i];
        used[node[i]]=1;//标记为已打击
    }
    int total=n-k;//假设全部的边都不存在，那么所有打击完成之后，所剩的联通分量就是n-k
                    //以下计算打击完成后的连通分量数
    for(int i=0;i<2*m;i++)//遍历所有的边
    {
        if(used[a[i].from]==0&&used[a[i].to]==0)//如果都没有被打击
        {
            if(finds(a[i].from)!=finds(a[i].to))//且在此前没有被连接在一起
            {
                total--;
                fa[finds(a[i].from)]=finds(a[i].to);
            }
        }
    }
    ans[k]=total;
    for(int i=k-1;i>=0;i--)
    {
        int t=node[i];
        total++;
        used[t]=0;//已修复，没有被打击
        for(int i=head[t];i!=-1;i=a[i].nex)//遍历修复的点的全部边
        {
            if(used[a[i].to]==0&&finds(t)!=finds(a[i].to))//如果可以连而且还没连
            {
                total--;
                fa[finds(t)]=finds(a[i].to);
            }
        }
        ans[i]=total;
    }
    for(int i=0;i<=k;i++)
    {
        cout<<ans[i]<<endl;
    }
    return 0;
}

让你确定每次打击之后还有多少个联通分量（并查集似乎顺着做不了），就只有逆着来做了

首先假设所有将要打击的点都被破坏，然后再一步一步重建，这就是正常的并查集了，但是链式向前星挺难的