“线段树分治+可撤销并查集”详解

参考博客：Schucking-Sattin

记录一下这个小科技。

板子题：CF1814F

题意： n个点m条边的无向图，但每个点有一个出现时间段，求哪些点满足存在某一个时刻与 1 相连。

Solution:

这个科技关注的主要是每一条边出现的时间段。但其实每个点有一个时间段，就可以推出每一条边出现的时间段，这个比较简单。

最暴力的做法就是每个时间点都做一次加边操作，加完边之后把 1 所属的连通块所有点打上标记，这是n^2。

浪费时间的有两个点：一是加边，二是给连通块的点打标记。

对于加边：我们发现一条边在某一个时刻加上了，下一个时刻可能还在，我们每次都加入这个边会很浪费时间，能不能留着它，只把那些时间结束的边删掉。

对于打标记：DFS这个连通块显然是愚蠢的，我们选择使用并查集在根部进行打标记操作。

目测就是一个可撤销并查集。

但仅仅选用可撤销并查集还不行。可撤销并查集并不是能撤销任意一条边，而是只能像栈一样撤销上一次的操作，也就是撤销最近加入的边。

如果我们每条边的时间是树状嵌套的还行，有交叉的话就变成了撤销任意一条边。

如下图，先加蓝边再加红边，那么在蓝边撤回时不满足可撤销并查集的条件，撤销的信息是无法维护的。

那只要我们消除时间段的交叉就可以进行撤销操作了，我们考虑把每条边的时间段切成一小段一小段，比如在每个开始或结束的地方都分段，就会变成下图情况：

现在黑色栈里的加边和撤销操作就可以匹配上了。

但这个做法有个致命的问题就是分段太多了，最多会分 n^2 个段，可不可以少分一些。我们发现可以用线段树来减少分段量。

将每条边的时间线段用线段树来分开，每条线段只会分成log个，并且可以保证分完后的所有线段不相交。

那么回到这题的做法：

我们以时间为轴，记录线段树上每个时间区间覆盖的边，然后对线段树进行 DFS，进入一个区间就在并查集里加入这个区间的所有边，离开时再撤销这些边。

线段树分治的重点在于叶子结点，当 DFS 到叶子结点时，就是到了某个具体的时间点，我们可以对在这个时间点下的答案进行计算或者维护，我们的 DFS 可以搜索到所有的时间点。

如何用并查集维护答案，我们不能把连通块的每一个点都打上标记，我们只能对连通块的根打懒标记，而对于连通块里的其他点，我们在某条边被删除的时候，把父亲的标记下放给儿子（也就是分裂后另一个连通块的根），在所有边都分裂完之后，就能保证原来的整个连通块都打上标记。

打标记时要注意一个情况：比如我们对当前时间 1 所在的连通块根 root 打上标记，然后下一个时间 root 和 1 分离了，我们又把另一个结点 x 跟 root 连边，当 x 和 root 的边撤销时，root 会把它的标记下放给 x ，但其实 x 并没有和 1 相连。这就需要我们把每个时间点的标记分开，一个简单的做法是当 x 连向 root 时，我们先让 $tag[x] -= tag[root]$ ，以后再下放回 x 时也不会使它被打上标记。

#include <algorithm>
#include <iostream>
#include <cstring>
#include <cstdio>
#include <cmath>
#define FOR() int le=e[u].size();for(int i=0;i<le;i++)
#define QWQ cout<<"QwQ\n";
#define ll long long
#include <vector>
#include <queue>
#include <map>
#define ls now<<1
#define rs now<<1|1

using namespace std;
const int N=501010;
const int qwq=303030;
const int inf=0x3f3f3f3f;

inline int read() {
    int sum = 0, ff = 1; char c = getchar();
    while(c<'0' || c>'9') { if(c=='-') ff = -1; c = getchar(); }
    while(c>='0'&&c<='9') { sum = sum * 10 + c - '0'; c = getchar(); }
    return sum * ff;
}

int T;
int n,m;
int da;
int L[N],R[N];
vector < pair<int,int> > t[N<<2];
struct CZ{
    int x,y,depy,tim;
}st[N];
int fa[N],tag[N],dep[N];
int cnt;

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

void insert(int now,int l,int r,int x,int y,pair<int,int>pa) {
    if(x<=l && r<=y) { t[now].push_back(pa); return ; }
    int mid = l+r >> 1;
    if(x<=mid) insert(ls, l, mid, x, y, pa);
    if(y>mid)  insert(rs, mid+1, r, x, y, pa);
}

void merge(int x,int y,int tim) {
    int xx = find(x), yy = find(y);
    if(xx==yy) return ;
    if(dep[xx] > dep[yy]) swap(xx,yy);   //  xx -> yy
    st[++cnt] = {xx, yy, dep[yy], tim};
    fa[xx] = yy;
    if(dep[xx]==dep[yy]) dep[yy]++;
    tag[xx] -= tag[yy];
}

void DFS(int now,int l,int r) {
    for(auto v : t[now]) {
        merge(v.first, v.second, now);
    }
    if(l==r) tag[find(1)]++;
    else {
        int mid = l+r >> 1;
        DFS(ls, l, mid);
        DFS(rs, mid+1, r);
    }
    while(st[cnt].tim==now) {
        CZ cz = st[cnt--];
        tag[cz.x] += tag[cz.y];
        fa[cz.x] = cz.x;
        dep[cz.y] = cz.depy;
    }
}

int main() {
    int x,y;
    n = read(); m = read();
    for(int i=1;i<=n;i++) L[i] = read(), R[i] = read(), da = max(da,R[i]);
    for(int i=1;i<=m;i++) {
        x = read(); y = read();
        int le = max(L[x], L[y]);
        int re = min(R[x], R[y]);
        if(le<=re) insert(1, 1, da, le, re, pair<int,int>{x,y});
    }
    for(int i=1;i<=n;i++) fa[i] = i;
    DFS(1, 1, da);
    for(int i=1;i<=n;i++) if(tag[i]) cout<<i<<" ";
    return 0;
}

例题 CF1681F：

题意： 给一颗树，每条边有颜色，求 $\sum\limits_{x=1}^n\sum\limits_{y=x+1}^nf(x,y)$ ， $f(x,y)$ 表示 x 到 y 之间的路径中只出现一次的颜色数量。

Solution：

暴力很好想，如何统计每个颜色对答案的贡献，只需把树上这个颜色的边全删掉，然后累加相邻连通块大小的乘积。（顺带一提，如果题目改为 $f(x,y)$ 表示 x 到 y 之间不同颜色数量，也可以这么来统计，只需让所有点对减去路径上不包含这个颜色边的点对）

这个题的情况就和模板很相似，如果每次重新加边复杂度就是n^2，如果用可撤销并查集，需要保证每次撤销是最近的操作，而我们的做法撤销的边并不是最近加入的边。

所以我们直接套模板，颜色为 c 的边出现的时间为 $[1,c-1]$ 和 $[c+1,n]$ ，把这两个时间段拆分到线段树上。

我们线段树 DFS 到叶子结点时表示时间为 c 的状态，也就是这个颜色的边全删掉的状态。

可撤销并查集维护连通块大小，实时更新答案。

#include <algorithm>
#include <iostream>
#include <cstring>
#include <cstdio>
#include <cmath>
#define FOR() ll le=e[u].size();for(ll i=0;i<le;i++)
#define QWQ cout<<"QwQ\n";
#define ll long long
#include <vector>
#include <queue>
#include <map>
#define ls now<<1
#define rs now<<1|1

using namespace std;
const ll N=501010;
const ll qwq=303030;
const ll inf=0x3f3f3f3f;

inline ll read() {
    ll sum = 0, ff = 1; char c = getchar();
    while(c<'0' || c>'9') { if(c=='-') ff = -1; c = getchar(); }
    while(c>='0'&&c<='9') { sum = sum * 10 + c - '0'; c = getchar(); }
    return sum * ff;
}

ll T;
ll n,m,da;
vector < pair<ll,ll> > t[N<<2];
vector < pair<ll,ll> > e[N];
struct CZ{
    ll x,y,depy,tim;
}st[N];
ll cnt;
ll fa[N],dep[N],siz[N];
ll ans;

ll find(ll x) { return x==fa[x] ? x : find(fa[x]); }

void insert(ll now,ll l,ll r,ll x,ll y,pair<ll,ll>pa) {
    if(x<=l && r<=y) { t[now].push_back(pa); return ; }
    ll mid = l+r >> 1;
    if(x<=mid) insert(ls, l, mid, x, y, pa);
    if(y>mid)  insert(rs, mid+1, r, x, y, pa);
}

void merge(ll x,ll y,ll tim) {
    ll xx = find(x), yy = find(y);
    if(xx==yy) return ;
    if(dep[xx] > dep[yy]) swap(xx,yy);   //  xx -> yy
    st[++cnt] = { xx, yy, dep[yy], tim };
    siz[yy] += siz[xx];
    dep[yy] += (dep[yy]==dep[xx]);
    fa[xx] = yy;
}

void DFS(ll now,ll l,ll r) {
    for(auto v : t[now]) {
        merge(v.first, v.second, now);
    }
    if(l==r) {
        for(auto v : e[l]) {
            ans += siz[find(v.first)] * siz[find(v.second)];
            // cout<<"l = "<<l<<" siz["<<v.first<<"] = "<<siz[find(v.first)]<<" siz["<<v.second<<"] = "<<siz[find(v.second)]<<"\n";
        }
    }
    else {
        ll mid = l+r >> 1;
        DFS(ls, l, mid);
        DFS(rs, mid+1, r);
    }
    while(st[cnt].tim==now) {
        CZ cz = st[cnt--];
        dep[cz.y] = cz.depy;
        siz[cz.y] -= siz[cz.x];
        fa[cz.x] = cz.x;
    }
}

int main() {
    ll x,y,z;
    n = read(); da = n;
    for(ll i=1;i<n;i++) {
        x = read(); y = read(); z = read();
        if(z!=1)  insert(1, 1, da, 1, z-1, pair<ll,ll>{x,y});
        if(z!=da) insert(1, 1, da, z+1, da, pair<ll,ll>{x,y});
        e[z].push_back( pair<ll,ll>{x,y} );
    }
    for(ll i=1;i<=n;i++) fa[i] = i, siz[i] = 1;
    DFS(1, 1, da);
    cout<<ans;
    return 0;
}

例题：P5631 最小mex生成树

题意：给一张带边权的无向连通图，求一棵生成树，其边权的mex值最小。

Solution：

其实思路和上题很像，我们把图中所有边权为 x 的边删掉，若图仍然连通，则可以构造一个生成树满足 $mex\le x$ ，因此我们找到最小的 x 即可。

并查集维护连通块大小， $size=n$ 说明全图连通。

#include <algorithm>
#include <iostream>
#include <cstring>
#include <cstdio>
#include <cmath>
#define FOR() int le=e[u].size();for(int i=0;i<le;i++)
#define QWQ cout<<"QwQ\n";
#define ll long long
#include <vector>
#include <queue>
#include <map>
#define ls now<<1
#define rs now<<1|1

using namespace std;
const int N=1201010;
const int qwq=303030;
const int inf=0x3f3f3f3f;

inline int read() {
    int sum = 0, ff = 1; char c = getchar();
    while(c<'0' || c>'9') { if(c=='-') ff = -1; c = getchar(); }
    while(c>='0'&&c<='9') { sum = sum * 10 + c - '0'; c = getchar(); }
    return sum * ff;
}

int T;
int n,m,da;
vector < pair<int,int> > t[qwq<<2];
struct CZ{
    int x,y,depy,tim;
}st[N];
int cnt;
int fa[N],dep[N],siz[N];

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

void insert(int now,int l,int r,int x,int y,pair<int,int>pa) {
    if(x<=l && r<=y) { t[now].push_back(pa); return ; }
    int mid = l+r >> 1;
    if(x<=mid) insert(ls, l, mid, x, y, pa);
    if(y>mid)  insert(rs, mid+1, r, x, y, pa);
}

void merge(int x,int y,int tim) {
    int xx = find(x), yy = find(y);
    if(xx==yy) return ;
    if(dep[xx] > dep[yy]) swap(xx,yy);   //  xx -> yy
    st[++cnt] = { xx, yy, dep[yy], tim };
    siz[yy] += siz[xx];
    dep[yy] += (dep[yy]==dep[xx]);
    fa[xx] = yy;
}

void DFS(int now,int l,int r) {
    for(auto v : t[now]) {
        merge(v.first, v.second, now);
    }
    if(l==r) {
        if(siz[find(1)]==n) { cout<<l-1; exit(0); }
    }
    else {
        int mid = l+r >> 1;
        DFS(ls, l, mid);
        DFS(rs, mid+1, r);
    }
    while(st[cnt].tim==now) {
        CZ cz = st[cnt--];
        dep[cz.y] = cz.depy;
        siz[cz.y] -= siz[cz.x];
        fa[cz.x] = cz.x;
    }
}

int main() {
    int x,y,z;
    n = read(); m = read(); da = 100005;
    for(int i=1;i<=m;i++) {
        x = read(); y = read(); z = read()+1;
        if(z!=1)  insert(1, 1, da, 1, z-1, pair<int,int>{x,y});
        if(z!=da) insert(1, 1, da, z+1, da, pair<int,int>{x,y});
    }
    for(int i=1;i<=n;i++) fa[i] = i, siz[i] = 1;
    DFS(1, 1, da);
    return 0;
}