Day 02-并查集

Day 02

并查集

• 解决的问题的本质：连通性问题的判断

• 树形结构中，节点代表集合，边代表关系

  1. 根节点：全集
  2. 子节点：子集

Quick-Union 算法

以上图为例，讨论节点之间的联通关系。1:[4,3] ,从节点4开始，连接节点3。即将节点4对应的值变为3，也可认为节点4成为根节点，节点3为它的子节点。

随堂练习 -1

最终结果：（ 5 和 6 是根节点）

0	1	2	3	4	5	6	7	8	9
1	2	4	4	5	5	6	6	9	7

图中有一个树遇见了极端情况——退化成一条链。

如何合并，用平均查找次数来判断。

随堂练习 -2

最重要的特点：按质合并 + 路径压缩

例题一(朋友圈问题)

1. 问题描述
   

2. 源代码展示：

   //71.cpp
   #include<iostream>
   using namespace std;
   
   #define MAX_N 10000
   
   struct UnionSet{//结构体定义
       int fa[MAX_N + 5] ;
       void init(int n){
           for (int i = 1; i <= n; i++) fa[i] = i ;
       }//开始时，每个人的父节点就是其本身，此为赋值操作
       int get(int x){
           if (x == fa[x]) return x ;
           return get(fa[x]) ;
           //return (fa[x] = (x = fa[x] ? x : get(fa[x]))) ;
       }
       void merge(int a, int b){
           fa[get(a)] = get(b) ;
       }
   };//并查集算法
   
   UnionSet u ;
   
   int main(){
       int n ,m ;
       cin >> n >> m ;
       u.init(n);//完成对每个节点的赋值(将其父节点的值表示出来)
       for(int i = 0; i<m ;i++){
           int a,b,c ;
           cin >> a >> b >> c ;
           switch(a){
               case 1 :{
                   u.merge(b, c) ;//对于新增信息构建相应的树(相应并查集)
               } break ;
               case 2 :{//判断两人是否属于一个朋友圈
                   cout << (u.get(b) == u.get(c) ? "Yes" : "No") << endl ;
               } break ;
           }
       }
       return 0 ;
   }
   

例题二(猜拳问题——带权并查集)

1. 问题描述：
   

2. 问题分析：

   因为是猜拳的特殊问题，可以想到如下情况：

   a->b->c->d->e->f （a能赢b，b能赢c，c能赢d；同时，a会输给c，a会和d打平手）

   可以得知，胜负关系是循环的，用不同的权值来表示不同的输赢关系：0平，1赢，2输

3. 源代码展示：

   //72.cpp
   #include<iostream>
   using namespace std;
   
   #define MAX_N 10000
   
   struct UnionSet{//结构体定义
       int fa[MAX_N + 5] ,val[MAX_N + 5];//记录父节点以及权值的数组
       void init(int n){
           for (int i = 1; i<= n ;i++){ 
               fa[i] = i ;
               val[i] = 0 ;
           }//初始时，每个节点均是自己的父节点，且权值为0，意味自己与自己打平
       }
       int get(int x){
           if (x == fa[x]) return x ;
           int root = get(fa[x]) ;
           val[x] += val[fa[x]] ;
           val[x] %= 3 ;
           return fa[x] = root ;
       }//处理带权问题的部分
       void merge(int a ,int b, int t){
           int aa = get(a), bb = get(b) ;
           if(aa == bb) return ;
           fa[aa] = bb ;
           val[aa] = (val[b] + t - val[a] + 3) % 3 ;
           return ;
       }
   };//带权并查集算法
   
   UnionSet u ;
   
   int main(){
       int n, m ;
       cin >> n >> m ;
       u.init(n) ;
       for(int i = 0; i < m ;i++){
           int a, b, c ;
           cin >> a >> b >> c ;
           switch(a){
               case 1 :{
                   u.merge(b, c, 1) ;
               } break ;
               case 2 :{
                   if(u.get(b) != u.get(c)){
                       cout << "Unknown" << endl ;
                   }//无法判定输赢的情况
                   else{
                       switch((u.val[b] - u.val[c] + 3) % 3){
                           case 0: cout << "Tie" << endl ; break ;
                           case 1: cout << "Win" << endl ; break ;
                           case 2: cout << "Loss" << endl ; break ;
                       }//根据最终计算出来的权值来判断输赢
                   }
               } break ;
           }
       }
       return 0 ;
   }