并查集

是一个可以动态维护若干个不重叠的集合，并支持合并与查询的数据结构。
核心操作：

const int N = 1000010;
int p[N];

void init(){
	p[i] = i;
}

int find(int x){
	if(p[x] != x)  p[x] = find(p[x]);
	return p[x];
}

void merge(int a,int b){
	int pa=find(a),pb=find(b);
	if(pa!=pb){
		p[pa] = pb;
	}
}

运用：

1. 路径压缩 & 按秩合并

AcWing 238. 银河英雄传说

难点：求并查集同根两点的间隔数

用size去维护每个连通块的个数，d[x]表示x到当前祖宗结点的距离，d[x]在find一次后会更新（路径压缩）
每次把size加到pa上，这样整个pa连通块上的点的d[i]，之后更新时都会加上这个size

核心：路径压缩的使用

int find(int x){
    if(p[x] != x){
        int root = find(p[x]);
        d[x] += d[p[x]];
        p[x] = root;
    }
    return p[x];
}
// size数组在根上记录集合大小
void merge(int a,int b){
	int pa = find(a);
  int pb = find(b);
  d[pa] = SIZE[pb];
  SIZE[pb] += SIZE[pa];
  p[pa] = pb;
}

根 -> 记录集合的大小
每个元素 -> 每个点到根的距离

2. “边带权”

边权来表示“相对关系”。
多个类的关系可以通过取mod来实现。

AcWing 239. 奇偶游戏

带边权的并查集,用边权来表示“相对”关系来处理有传递性的问题（将每个节点传递到与根节点的关系）
d[x] 来表示 x 与 p[x] 的关系（0 -> 同类，1 -> 异类）
某种性质以点来表示

int find(int x){
    if(p[x] != x){
        int root = find(p[x]);
        d[x] += d[p[x]];
//        d[x] ^= d[p[x]];      要一一对应
        p[x] = root;
    }
    return p[x];
}

void merge(int a,int b){
        int pa = find(a);
        int pb = find(b);
        if(pa == pb){
            if (((d[a] + d[b]) % 2 + 2) % 2 != t)
//            if ((d[a] ^ d[b])!= t)          要用^就前后都要^
            {
                lop = false;
                break;
            }
        }
        else{
            p[pa] = pb;
            d[pa] = d[a]^d[b]^t;
        }
    }
}

ps. 多种关系以 mod 来区分

AcWing 240. 食物链

思路：
核心：还是将每个点之间的关系转换到与根的关系（路径压缩），要注意是否是同根，不同的话考虑 合并merge 操作

#include
using namespace std;
const int N = 50010;
int n,m;
int p[N],d[N];

int find(int x){
    if(p[x] != x){
        int t = find(p[x]);
        d[x] += d[p[x]];
        p[x] = t;
    }
    return p[x];
}

int main(){
    cin >> n >> m;
    for(int i=1;i<=n;i++) p[i] =  i;
    int res = 0;
    while(m--){
        int t,x,y;
        cin >> t >> x >> y;
        if(x > n || y > n) res++;
        else{
            int px=find(x);
            int py=find(y);
            if(t==1){
                if(px == py && (d[x] - d[y])%3) res++;
                else if(px != py){
                    p[px] = py;
                    d[px] = d[y] - d[x];
                }
            }
            else{
                if(px == py && (d[x]-d[y]-1)%3) res++;
                else if(px != py){
                    p[px] = py;
                    d[px] = d[y] + 1 - d[x];
                }
            }
        }
    }
    cout << res << endl;
    return 0;
}

3. 扩展域

AcWing 239. 奇偶游戏

核心：集合中存储的是条件

4. 并查集的多次使用

红色警报

利用结构体将每次合并操作记录；
多次利用并查集：记录每次删除一个城市后，连通块的数量（ p[ i ] = i )，比较前后差异，就可以得出连通性有无影响

如果连通个数不变（攻占本来就不连通的城市），或者连通个数比原来多1（攻占与其他城市连通的城市，因为只是攻占的城市被单独出来，因此连通集个数会多1），不发生红色警报。
如果说攻占的城市导致连通性发生改变那么整体新建立的连通集个数至少比原来多2个！则会发生红色警报

code：

#include
#include
using namespace std;
const int N = 10000010;
int p[N];

int find(int x){
    if(p[x] != x) p[x] = find(p[x]);
    return p[x];
}

void merge(int a,int b){
    int pa = find(a), pb = find(b);
    if(pa != pb){
        p[pa] = pb;
    }
}

struct NODE{
    int x;
    int y;
}node[N];

int lop[N],c[N];

int main(){
    int n,m;
    cin >> n >> m;
    for(int i=0;i<n;i++){
        p[i] = i;
    }
    for(int i=0;i<m;i++){
        int a,b;
        cin >> a >> b;
        node[i].x = a;
        node[i].y = b;
        merge(a,b);
    }
    int num=0;
    for(int i=0;i<n;i++){
        if(p[i] = i) num++;
    }
    int k;
    cin >> k;
    for(int i=0;i<k;i++){
        int x,cnt=0;
        cin >> x;
        lop[x] = 1;
        for(int j=0;j<n;j++)    p[j] = j;
        for(int j=0;j<m;j++){
            if(lop[node[j].x] || lop[node[j].y]) continue;
            merge(node[j].x,node[j].y);
        }
        for(int j=0;j<n;j++){
            if(p[j] == j) cnt++;
        }
        if(num >= cnt-1) cout << "City " << x << " is lost." <<endl;
        else cout << "Red Alert: City " << x << " is lost!" <<endl;
        num = cnt;
    }
    if(k >= n) cout << "Game Over.";
    return 0;
}

continue ~ ~