P1197 [JSOI2008]星球大战 [删边求连通块个数]

 展开

题目描述

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

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

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

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

输入格式

输入文件第一行包含两个整数，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

 

 思路

　　对于删边求连通块个数问题, 就我遇到的来说,一般可以考虑暴搜,并查集和tarjan来做.

　　对于此题来说, 显然用并查集做更简单, 考虑用并查集实现.

　　由于并查集写删边的码量很大很复杂, 但是建边很容易, 所以考虑反向处理.

　　首先, 令所有点都是单独的连通块, 因为炸掉了就不能参与构成连通块了, 所以先处理出剩下了多少可以操作的连通块.

　　令最终态就是此时的连通块个数, 接着反向加点连边.

　　每加上一个点, 连通块的个数肯定就要 + 1 , 然后遍历炸点之前它可以连的边, 如果连上一个连通块, 那么对应的此时连通块个数就要 - 1 ;

　　最后就可以处理出每个点炸点前的连通块数量, 反向输出即可.

CODE

#include <bits/stdc++.h>
#define dbg(x) cout << #x << "=" << x << endl
#define eps 1e-8
#define pi acos(-1.0)

using namespace std;
typedef long long LL;

template<class T>inline void read(T &res)
{
    char c;T flag=1;
    while((c=getchar())<'0'||c>'9')if(c=='-')flag=-1;res=c-'0';
    while((c=getchar())>='0'&&c<='9')res=res*10+c-'0';res*=flag;
}

namespace _buff {
    const size_t BUFF = 1 << 19;
    char ibuf[BUFF], *ib = ibuf, *ie = ibuf;
    char getc() {
        if (ib == ie) {
            ib = ibuf;
            ie = ibuf + fread(ibuf, 1, BUFF, stdin);
        }
        return ib == ie ? -1 : *ib++;
    }
}

int qread() {
    using namespace _buff;
    int ret = 0;
    bool pos = true;
    char c = getc();
    for (; (c < '0' || c > '9') && c != '-'; c = getc()) {
        assert(~c);
    }
    if (c == '-') {
        pos = false;
        c = getc();
    }
    for (; c >= '0' && c <= '9'; c = getc()) {
        ret = (ret << 3) + (ret << 1) + (c ^ 48);
    }
    return pos ? ret : -ret;
}

const int maxn = 2e5 + 7;

int cnt, head[maxn << 2], edge[maxn << 2], nxt[maxn << 2], from[maxn << 2];
bool vis[maxn << 1];
int a[maxn << 1], ans[maxn << 1],fa[maxn << 1];
int tot,n,m,x,y,k;

void BuildGraph(int u, int v) {
    cnt++;
    edge[cnt] = v;
    from[cnt] = u;
    nxt[cnt] = head[u];
    head[u] = cnt;
}

int fid(int x) {
    return x == fa[x] ? x : fa[x] = fid(fa[x]);
}

int main()
{
    scanf("%d %d",&n, &m);
    for ( int i = 1; i <= m; ++i ) {
        int u, v;
        scanf("%d %d",&u, &v);
        BuildGraph(u, v);
        BuildGraph(v, u);
    }
    scanf("%d",&k);
    for ( int i = 1; i <= k; ++i ) {
        int x;
        scanf("%d",&x);
        vis[x] = 1;
        a[i] = x;
    }
    for ( int i = 1; i <= n; ++i ) {
        fa[i] = i;
    }
    tot = n - k;
    for ( int i = 1; i <= 2 * m; ++i ) {
        if(!vis[from[i]] && !vis[edge[i]]) {
            if(fa[fid(from[i])] != fa[fid(edge[i])]) {
                tot--;
                fa[fid(from[i])] = fa[fid(edge[i])];
            }
        }
    }
    ans[k+1] = tot;
    for ( int i = k; i >= 1; --i ) {
        int x = a[i];
        vis[x] = 0;
        tot++;
        for ( int j = head[x]; j; j = nxt[j] ) {
            if(vis[edge[j]] == 0 && fa[fid(x)] != fa[fid(edge[j])]) {
                tot--;
                fa[fid(x)] = fa[fid(edge[j])];
            }
        }
        ans[i] = tot;
    }
    for ( int i = 1; i <= k+1; ++i ) {
        printf("%d
",ans[i]);
    }
    return 0;
}