并查集的应用

并查集可以有很多应用。比如权值并查集或带扩展域的并查集，可以来维护一些可传递的关系。当然，并查集最直接的应用，则是来维护集合的的连通关系。

第一题
题意：给出一幅图，以及一系列操作，每次操作删去一个点，及这个点相关的所有边，并输出删点之后的连通块个数。
思路：这道题把过程倒着来就好了，可以看成建图的过程，如果要新加一条边，这条边连接的两个点若是在不同的连通块内，连边后，联通快个数就++。

#include
#include
using namespace std;
const int MAXN = 4e5+5;

vector<int> v[MAXN];
vector<int> ans;
struct Edge{
     
    int u, v;
}edge[MAXN];
struct Point{
     
    int p;
}point[MAXN];
bool book[MAXN];
int n, m, k;

//并查集部分
int pre[MAXN];
int getFather(int u){
     
    if(pre[u] == u) return u;
    return pre[u] = getFather(pre[u]);
}
void merge(int u, int v){
     
    int fu = getFather(u);
    int fv = getFather(v);
    if(fu != fv) pre[fu] = fv;
}

int main() {
     
    ios::sync_with_stdio(0);
    cin.tie(0);

    cin >> n >> m;
    for(int i = 0; i <= n; ++i)
        pre[i] = i;
    for(int i = 1; i <= m; ++i){
     
        cin >> edge[i].u >> edge[i].v;
    }
    cin >> k;
    int x;
    for(int i = 1; i <= k; ++i){
     
        cin >> x;
        book[x] = true;
        point[i].p = x;
    }

    int tot = 0;

    for(int i = 1; i <= m; ++i){
     
        if(book[edge[i].u] == false && book[edge[i].v] == false){
      //直接加入并查集
            merge(edge[i].u, edge[i].v);
        } else{
      //建图
            v[edge[i].u].push_back(edge[i].v);
            v[edge[i].v].push_back(edge[i].u);
        }
    }

    for(int i = 0; i < n; ++i){
      //求出连通块数量
        if(getFather(i) == i) tot++;
    }
    tot -= k;
    ans.push_back(tot);
    for(int i = k; i >= 1; --i){
     
        int node = point[i].p;
        int len = v[node].size();
        for(int j = 0; j < len; ++j){
     
            if(getFather(node) != getFather(v[node][j]) && book[v[node][j]] == false){
     
                merge(node, v[node][j]);
                tot--;
            }
        }
        tot++;
        book[node] = false;
        ans.push_back(tot);
    }
    int len = ans.size();
    for(int i = len-1; i >= 0; --i){
     
        cout << ans[i] << endl;
    }
    return 0;
}

第二题
这题并查集有两个应用，因为每一个点都只能有一次从0变到1，所以我们对于每一行可以维护一个并查集，每个点指向右端第一个0，这样利用并查集“暴力修改”即可。然后总体的连通性再开一个并查集维护

#include
#include
using namespace std;
const int MAXN = 4e5+5;

int tot;
int n, m, q;
char mp[1005][1005];

//并查集维护每一行的连通情况，每个连通块最右端为0
int rt[1005][1005]; //right[i][j]代表第i行第j列的父亲，根节点指向右边第一个0
int getFirstZero(int row, int col){
     
    if(rt[row][col] == col)
        return col;
    return rt[row][col] = getFirstZero(row, rt[row][col]);
}
void link(int row, int u, int v){
     
    int fu = getFirstZero(row, u);
    int fv = getFirstZero(row, v);
    if(fu != fv) rt[row][fu] = rt[row][fv];
}

//并查集维护所有1块的连通情况
int pre[1005*1005];
int getFather(int u){
     
    if(pre[u] == u) return u;
    return pre[u] = getFather(pre[u]);
}
int merge(int u, int v){
      //顺便维护连通块个数
    int fu = getFather(u), fv = getFather(v);
    if(fu != fv){
     
        pre[fu] = pre[fv];
        tot--;
    }
}

int main(){
     
    ios::sync_with_stdio(0);
    cin.tie(0);

    //获取输入
    cin >> n >> m;
    for(int i = 1; i <= n; ++i){
     
        for(int j = 1; j <= m; ++j){
     
            cin >> mp[i][j];
        }
        mp[i][m+1] = '0';
    }
    
    //预处理每行连通块情况
    for(int i = 1; i <= n; ++i){
     
        for(int j = 1; j <= m+1; ++j){
     
            rt[i][j] = j;
        }
    }
    for(int i = 1; i <= n; ++i){
     
        for(int j = 1; j <= m+1; ++j){
     
            if(mp[i][j] == '1') link(i, j, j+1);
        }
    }

    //预处理总体连通情况
    for(int i = 1; i <= n; ++i)
        for(int j = 1; j <= m; ++j)
            pre[i*m+j] = i*m+j;
    for(int i = 1; i <= n; ++i){
     
        for(int j = 1; j <= m; ++j){
     
            if(mp[i][j] == '1'){
     
                if(j+1 <= m && mp[i][j+1] == '1') merge(i*m+j, i*m+j+1);
                if(i+1 <= n && mp[i+1][j] == '1') merge(i*m+j, (i+1)*m+j);
            }
        }
    }
    tot = 0;
    for(int i = 1; i <= n; ++i){
     
        for(int j = 1; j <= m; ++j){
     
            if(mp[i][j] == '1' && getFather(i*m+j) == i*m+j) tot++;
        }
    }

    //输入给定区域
    cin >> q;
    int x1, x2, y1, y2;
    while(q--){
     
        cin >> x1 >> y1 >> x2 >> y2;
        for(int r = x1; r <= x2; ++r){
      //对每一行检查
            int tmp = getFirstZero(r, y1);
            while(tmp <= y2){
     
                tot++;
                mp[r][tmp] = '1';
                link(r, tmp, tmp+1);
                if(r-1 >= 1 && mp[r-1][tmp] == '1') merge(r*m+tmp,(r-1)*m+tmp); //可以与上面连通
                if(r+1 <= n && mp[r+1][tmp] == '1') merge(r*m+tmp, (r+1)*m+tmp); //可以与下面连通
                if(tmp-1 >= 1 && mp[r][tmp-1] == '1') merge(r*m+tmp, r*m+tmp-1); //可以与左边连通
                if(tmp+1 <= m && mp[r][tmp+1] == '1') merge(r*m+tmp, r*m+tmp+1); //可以与右边连通
                tmp = getFirstZero(r, tmp);
            }
            
        }

        cout << tot << endl;
    }
    return 0;
}