并查集：星球大战

题目链接

蓝桥云课-星球大战

题目大意

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

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

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

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

输入格式

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

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

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

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

输出格式

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

样例输入 #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\%$ 的数据，$1\le m\le 2\times 10^5$，$1\le n\le 2m$，$x\ne y$。

解题思路

反向思维+并查集

本质数据结构——图
正向思维过程：
1、构造 $n$ 个结点，这 $n$ 个结点分别代表编号 $0\sim n-1$ 的星球；
2、 $m$ 条“以太隧道”所关联的 2 个星球进行连边；
3、破坏第 $k$ 个星球前对图进行搜索，计算连通集的个数；
4、对于每一次摧毁星球，删去图中该星球结点以及该结点连通的边。回到步骤3，对图进行搜索，计算连通集个数；
5、结束。

问题——算法效率过低
每一次摧毁星球会带来的重新搜索

连通问题——并查集
期望：使用并查集来维护星球间的连通状态。
问题：摧毁星球会减少连通边的个数，而并查集并不适用于集合的分割。

逆向思维过程
正向不断摧毁是分割集合，逆向思维，假设一开始所有的 $k$ 的被破坏的星球都不存在，之后将这 $k$ 个星球逆序修复，在这个过程中不断计算并查连通集的数量。
1、描述图数据结构：需要定义连边和节点，描述星球的连接路径；
2、记录星球状态：需要一个数组 broken 记录星球是否会被破坏默认值为 $false$，对于所有的 $k$ 个会被破坏的星球， broken$[i]$ 设置为 $true$ ；
3、记录连通集合数量：需要一个变量 $block\_num$ 表示当前连通集合的数量。由于未连边时所有星球都不连通，则 $block\_num$ 初始值为 $n-k$ ；
4、并查集模板：对两个星球结点进行连接操作时，判断所有没有毁坏的星球的连通状态，进行并查集的合并操作，每合并一次两个结点，连通集合的数量就减少 1 ；
5、记录逆序修复后的结果：定义一个长度为 $k+1$ 的列表 res 记录每一次逆序修复的答案。
6、如何执行：
(1) 初始：修复在对所有 broken$[i]=true$ 的安全星球结点全部连接完毕后，此时的并查集状态相当于摧毁了所有 $k$ 个星球后的状态，因此 res$[k+1]=block\_num$ 。
(2) 迭代：加下来逆序枚举 $k$ 个被摧毁星球的编号，并将结点一一修复，对修复的节点进行并查集的合并操作，计算维护 $block\_num$ 的值。

AC Code

Python3

# -*- coding: utf-8 -*-
# @Author : BYW-yuwei
# @Software: python3.8.6
M=int(2e5)+5
N=2*M
class node:
    def __init__(self,prev:int,to:int,next:int):
        self.prev=prev
        self.to=to
        self.next=next

broke_pos=[-1]*N ; broken=[False]*N
father=[0]*N
edge=[node(-1,-1,-1)]           #保存结点之间连边的列表
first=[0]*N
edge_idx=1
def init(n:int):                #并查集的模板
    for i in range(n+1):
        father[i]=i
def find_father(x:int):
    if father[x]==x:return x
    f=find_father(father[x])
    father[x]=f
    return f
def unite(x:int,y:int):
    x=find_father(x) ; y=find_father(y)
    if x==y:return 
    else:father[x]=y

def add_edge(e1:int,e2:int):    #添加边的函数
    global edge_idx
    cu_node=node(e1,e2,first[e1])
    edge.append(cu_node)
    first[e1]=edge_idx
    edge_idx+=1

res=[0]*N
if __name__=="__main__":
    n,m=map(int,input().split())
    init(n)
    for i in range(m):
        x,y=map(int,input().split())
        add_edge(x,y) ; add_edge(y,x)   #由于是无向边，所以需要双向连边
    k=int(input())
    for i in range(1,k+1):
        broke_pos[i]=int(input())
        broken[broke_pos[i]]=True
    block_num=n-k
    for i in range(1,2*m+1):            #先连接所有的安全星球
        pos1=edge[i].prev ; pos2=edge[i].to
        if (not broken[pos1]) and (not broken[pos2]) and (find_father(pos1)!=find_father(pos2)):
            unite(pos1,pos2)
            block_num-=1
    res[k+1]=block_num
    for i in range(k,0,-1):             #逆向修复被破坏的星球
        block_num+=1
        broken[broke_pos[i]]=False
        j=first[broke_pos[i]]
        while j:
            if (not broken[edge[j].to]) and (find_father(broke_pos[i])!=find_father(edge[j].to)):
                block_num-=1
                unite(broke_pos[i],edge[j].to)
            j=edge[j].next
        res[i]=block_num
    for i in range(1,k+2):print(res[i])