CF938G Shortest Path Queries 和 CF576E Painting Edges

这两道都用到了线段树分治和按秩合并可撤销并查集。

Shortest Path Queries

给出一个连通带权无向图,边有边权,要求支持 q 个操作:

1. x y d 在原图中加入一条 x 到 y 权值为 d 的边
2. x y 把图中 x 到 y 的边删掉
3. x y 表示询问 x 到 y 的异或最短路

保证任意操作后原图连通无重边自环且操作均合法

n,m,q≤200000

题解

与WC2011 最大XOR和路径一样，先考虑没有加边删边的做法

1. 做出原图的任意一棵生成树
2. 把每个非树边和树边形成的环丢进线性基里
3. 询问时把两点在树上的路径异或和丢进线性基里求最小异或和

有加边删边呢？线段树分治即可。

每到一个点，把边都连上，然后分治左右。退出时撤销即可。

需要用到按秩合并并查集以支持快速查询和撤销操作。并查集在合并两个点时，将儿子节点压入栈，撤销时直接把儿子节点的贡献删除即可。

#include
using namespace std;
template T read(){
    T x=0,w=1;char c=getchar();
    for(;!isdigit(c);c=getchar())if(c=='-') w=-w;
    for(;isdigit(c);c=getchar()) x=x*10+c-'0';
    return x*w;
}
template T read(T&x){
    return x=read();
}
#define co const
#define il inline
typedef long long LL;

co int N=200000+10;
struct edge {int u,v,w,l,r;}e[N<<1];

vector g[N<<2];
map,int> mp;
int val[N],fa[N],siz[N];
int stk[N<<1],top;
#define lc (x<<1)
#define rc (x<<1|1)
void update(int x,int l,int r,co edge&e){
    if(e.l>e.r) return; // edit 1
    if(e.l<=l&&r<=e.r)
        return g[x].push_back(e);
    int mid=(l+r)>>1;
    if(e.l<=mid) update(lc,l,mid,e);
    if(e.r>mid) update(rc,mid+1,r,e);
}

struct ask {int u,v;}qst[N];
int bas[20][30];

int find_fa(int x){
    return fa[x]==x?x:find_fa(fa[x]);
}
int find_val(int x){
    return fa[x]==x?0:val[x]^find_val(fa[x]);
}
void insert(int x,int dep){
    for(int i=0;i<(int)g[x].size();++i){
        int u=g[x][i].u,v=g[x][i].v,w=g[x][i].w;
        int fu=find_fa(u),fv=find_fa(v);
        if(fu!=fv){
            if(siz[fu]>siz[fv]) swap(fu,fv),swap(u,v);
            fa[fu]=fv,siz[fv]+=siz[fu],val[fu]=find_val(u)^find_val(v)^w;
            stk[++top]=fu;
        }
        else{
            w^=find_val(u)^find_val(v);
            for(int j=29;j>=0;--j)if(w>>j&1){
                if(!bas[dep][j]) {bas[dep][j]=w;break;}
                w^=bas[dep][j];
            }
        }
    }
}
void reset(int to){
    for(;top>to;--top){
        int u=stk[top];
        siz[fa[u]]-=siz[u],val[u]=0,fa[u]=u;
    }
}
void solve(int x,int l,int r,int dep){
    int tmp=top;
    insert(x,dep);
    if(l==r){
        int u=qst[l].u,v=qst[l].v;
        int ans=find_val(u)^find_val(v);
        for(int i=29;i>=0;--i)if(ans>>i&1)
            if(bas[dep][i]) ans^=bas[dep][i];
        printf("%d\n",ans);
        return reset(tmp);
    }
    int mid=(l+r)>>1;
    copy(bas[dep],bas[dep]+30,bas[dep+1]),solve(lc,l,mid,dep+1);
    copy(bas[dep],bas[dep]+30,bas[dep+1]),solve(rc,mid+1,r,dep+1);
    reset(tmp);
}

int main(){
    int n=read(),m=read();
    int ecnt=0;
    for(int i=1;i<=m;++i){
        int u=read(),v=read(),w=read();
        e[++ecnt]=(edge){u,v,w,1,-1},mp[make_pair(u,v)]=ecnt;
    }
    int q=read();
    int totq=0;
    for(int i=1;i<=q;++i){
        int opt=read();
        if(opt==1){ // add
            int x=read(),y=read(),d=read();
            e[++ecnt]=(edge){x,y,d,totq+1,-1},mp[make_pair(x,y)]=ecnt;
        }
        else if(opt==2){ // remove
            int x=read(),y=read();
            e[mp[make_pair(x,y)]].r=totq,mp[make_pair(x,y)]=0;
        }
        else{ // calculate
            int x=read(),y=read();
            qst[++totq]=(ask){x,y};
        }
    }
    for(int i=1;i<=ecnt;++i){
        if(e[i].r==-1) e[i].r=totq;
        update(1,1,totq,e[i]);
    }
    for(int i=1;i<=n;++i) fa[i]=i,siz[i]=1;
    solve(1,1,totq,0);
    return 0;
}

我写的线段树是需要判断插入合不合法的，好几次因为这个RE了。

Painting Edges

与BZOJ4025 二分图类似，这道题可以用并查集来维护奇环。

但是这道题我们并不知道每条边的具体存在时间，因此我们这样：
假设每次修改都生效，我们把每条边的第一种颜色的存在时间加入分治结构(其实就是线段树)
DFS的过程中，如果DFS到一个叶节点时，判断当前修改能否执行，这样我们就得到了这条边在下一个时间段的颜色，然后将这条边的下一个时间段加入分治结构

时间复杂度O(q log q log n)。话说我这两道题写的并查集都是假的也没人来卡我。

#include
using namespace std;
template T read(){
    T x=0,w=1;char c=getchar();
    for(;!isdigit(c);c=getchar())if(c=='-') w=-w;
    for(;isdigit(c);c=getchar()) x=x*10+c-'0';
    return x*w;
}
template T read(T&x){
    return x=read();
}
#define co const
#define il inline
typedef long long LL;

co int N=500000+10;
int n,m,K,Q;
struct edge {int u,v,c;}e[N];
struct ask {int e,c,r;}q[N];
int last[N];

int stk[N],col[N],top;
struct Disj{
    int fa[N],val[N],siz[N];
    
    int find_fa(int x){
        return fa[x]==x?x:find_fa(fa[x]);
    }
    int find_val(int x){
        return fa[x]==x?0:val[x]^find_val(fa[x]);
    }
    void merge(int c,int x,int y){
        int fx=find_fa(x),fy=find_fa(y);
        if(fx==fy) return;
        if(siz[fx]>siz[fy]) swap(fx,fy),swap(x,y);
        fa[fx]=fy,siz[fy]+=siz[fx],val[fx]=find_val(x)^1^find_val(y);
        stk[++top]=fx,col[top]=c;
    }
}d[51];
void reset(int tmp){
    for(;top>tmp;--top){
        int u=stk[top],c=col[top];
        d[c].siz[d[c].fa[u]]-=d[c].siz[u],d[c].fa[u]=u,d[c].val[u]=0;
    }
}

vector > g[N<<2];
#define lc (x<<1)
#define rc (x<<1|1)
void insert(int x,int l,int r,int ql,int qr,co pair&v){
    if(ql>qr) return;
    if(ql<=l&&r<=qr)
        return g[x].push_back(v);
    int mid=(l+r)>>1;
    if(ql<=mid) insert(lc,l,mid,ql,qr,v);
    if(qr>mid) insert(rc,mid+1,r,ql,qr,v);
}
void solve(int x,int l,int r){
    int tmp=top;
    for(int i=0;i<(int)g[x].size();++i){
        int e=g[x][i].first,c=g[x][i].second;
        d[c].merge(c,::e[e].u,::e[e].v);
    }
    if(l==r){
        int u=e[q[l].e].u,v=e[q[l].e].v,c=q[l].c;
        if(d[c].find_fa(u)!=d[c].find_fa(v) or d[c].find_val(u)!=d[c].find_val(v))
            puts("YES"),e[q[l].e].c=q[l].c;
        else puts("NO");
        insert(1,1,Q,l+1,q[l].r,make_pair(q[l].e,e[q[l].e].c));
        return reset(tmp);
    }
    int mid=(l+r)>>1;
    solve(lc,l,mid),solve(rc,mid+1,r);
    reset(tmp);
}

int main(){
    read(n),read(m),read(K),read(Q);
    for(int i=1;i<=m;++i) read(e[i].u),read(e[i].v);
    for(int i=1;i<=Q;++i){
        int id=read(),c=read();
        if(last[id]) q[last[id]].r=i-1;
        q[i]=(ask){id,c,Q},last[id]=i;
    }
    for(int c=1;c<=K;++c)
        for(int i=1;i<=n;++i) d[c].fa[i]=i,d[c].siz[i]=1;
    solve(1,1,Q);
    return 0;
}