[NOI2021] 轻重边

合集 - 题解(24)

1.[TK] 矩阵取数游戏<简单版> hzoi-tg-906-22024-02-15 2.[TK] 一心净士 hzoj-tg-937-22024-02-14 3.[TK] 盖房子 hzoi-tg#2622024-02-16 4.[TK] 三角蛋糕 hzoi-tg#2612024-02-16 5.[TK] 选课 hzoj-tg#2792024-02-16 6.[TK] 三色二叉树 hzoi-tg#282 存图方法2024-02-16 7.[TK] HH的项链离线树状数组解法2024-02-18 8.[TK] 理想的正方形2024-02-22 9.[TK] Blocks 单调栈2024-02-22 10.[TK] 送礼物2024-02-23 11.[TK] Terrible Prime2024-03-05 12.[TK] BLO2024-03-11 13.[TK] Rudolf and Subway ( CodeForces #933 div.3 - G )2024-03-18 14.[TK] Bulls And Cows S2024-04-13 15.[TK] 颜色2024-04-22 16.[Tkey] 与非2024-06-23 17.[TK] CF1526B I Hate 11112024-08-06 18.[TK] 寻宝游戏2024-08-09 19.[CL-22] 异或和之和2024-09-27 20.联训题单 / 集训杂题纪要2024-11-11 21.[At_dp_w] Intervals & [At_dp_x] Tower2024-11-08 22.CF2023D - Many Games2024-11-10

23.[NOI2021] 轻重边2024-11-13

24.[CSP-S 2024] 染色2024-11-20

气死我了这题，还是写一下题解

首先有一个非常好的转化，你可以把给定操作转为树上颜色问题

假设将操作 $1$ 改成 “将从 $x$ 到 $y$ 路径上的所有点都涂上一种新的颜色”，那么可以发现，与路径上的点相邻的所有非路径点，与路径上的点颜色必然不同，路径上的点之间两两必然相同

因此就可以定义重边为 “端点颜色相同的边”，轻边为 “端点颜色不同的边”，这样就可以将原问题转为树上数颜色问题

转化到这里就很好做了，由于数颜色是合并连通块，可以直接树剖之后放到线段树上去做，维护当前连续段长度，左端点，右端点，然后每次尝试在中间合并（合并最多只会增加 $1$ 的贡献）

操作要求我们支持区间修改与区间查询

对于区间修改，修改后整体覆盖的区间，其连通块个数应为 $l e n - 1$ 而不是 $l e n$ ，因为我们求的是联通的边数而不是点数

对于区间查询，同样维护长度，左端点与右端点，询问时分治并尝试在中间合并

然后是这个树剖的查询操作，这里不能无脑跳，因为我们需要合并连续段，因此必须知道当前链哪端是左边哪端是右边，这个可以通过维护一个变量来记录当前跳的是左边点还是右边点，然后通过深度低的点更靠左来判断左右端点

这个题需要特判颜色初值 $0$ ，因为 $0$ 和 $0$ 不能被称为颜色相等的点（初始所有点都是轻边）

因为懒得特判所以为点赋了不同初值，没想到最后发现和树剖的初值在值域上有交

#include<bits/stdc++.h>
using namespace std;
#define clearzero(x) memset((x),0,sizeof(x))
struct tree{
    int lc,rc;
    int lazy;
    int tot;
}t[100001*4];
int wnew[100001];
#define tol (id*2)
#define tor (id*2+1)
#define mid(l,r) mid=((l)+(r))/2
void pushdown(int id,int l,int r){
    if(t[id].lazy){
        int mid(l,r);
        t[tol]={t[id].lazy,t[id].lazy,t[id].lazy,mid-l};
        t[tor]={t[id].lazy,t[id].lazy,t[id].lazy,r-(mid+1)};
        t[id].lazy=0;
    }
}
void update(int id){
    t[id].lc=t[tol].lc;
    t[id].rc=t[tor].rc;
    t[id].tot=t[tol].tot+t[tor].tot+(t[tol].rc==t[tor].lc);
}
void build(int id,int l,int r){
    if(l==r){
        t[id]={-wnew[l],-wnew[l],0,0};
        return;
    }
    int mid(l,r);
    build(tol,l,mid);
    build(tor,mid+1,r);
    update(id);
}
void change(int id,int l,int r,int L,int R,int val){
    if(L<=l and r<=R){
        t[id]={val,val,val,r-l};
        return;
    }
    pushdown(id,l,r);
    int mid(l,r);
    if(R<=mid) change(tol,l,mid,L,R,val);
    else if(L>=mid+1) change(tor,mid+1,r,L,R,val);
    else{
        change(tol,l,mid,L,mid,val);
        change(tor,mid+1,r,mid+1,R,val);
    }
    update(id);
}
tree ask(int id,int l,int r,int L,int R){
    if(L<=l and r<=R){
        return t[id];
    }
    pushdown(id,l,r);
    int mid(l,r);
    if(R<=mid) return ask(tol,l,mid,L,R);
    else if(L>=mid+1) return ask(tor,mid+1,r,L,R);
    tree a=ask(tol,l,mid,L,mid),b=ask(tor,mid+1,r,mid+1,R);
    return {a.lc,b.rc,0,a.tot+b.tot+(a.rc==b.lc)};
}
int n,m;
vector<int>e[100001];
int deep[100001],fa[100001];
int size[100001],maxson[100001];
int id[100001],top[100001],idcnt;
int dfn[100001],dfncnt;
void dfs1(int now,int last){
    fa[now]=last;
    deep[now]=deep[last]+1;
    dfn[last]=++dfncnt;
    size[now]=1;
    int maxsonsize=0;
    for(int i:e[now]){
        if(i!=last){
            dfs1(i,now);
            size[now]+=size[i];
            if(size[i]>maxsonsize){
                maxsonsize=size[i];
                maxson[now]=i;
            }
        }
    }
}
void dfs2(int now,int nowtop){
    top[now]=nowtop;
    id[now]=++idcnt;
    if(!maxson[now]) return;
    dfs2(maxson[now],nowtop);
    for(int i:e[now]){
        if(i!=fa[now] and i!=maxson[now]){
            dfs2(i,i);
        }
    }
}
void change_path(int x,int y,int val){
    while(top[x]!=top[y]){
        if(deep[top[x]]<deep[top[y]]) swap(x,y);
        change(1,1,n,id[top[x]],id[x],val);
        x=fa[top[x]];
    }
    if(deep[x]<deep[y]) swap(x,y);
    change(1,1,n,id[y],id[x],val);
}
int ask_path(int x,int y){
    tree ans1={-1-2*n,-2-2*n,0,0},ans2={-3-2*n,-4-2*n,0,0};
    bool isans1=true;
    while(top[x]!=top[y]){
        if(deep[top[x]]<deep[top[y]]){
            isans1^=1;
            swap(x,y);
        }
        tree res=ask(1,1,n,id[top[x]],id[x]);
        if(isans1){
            ans1={ans1.lc,res.lc,0,ans1.tot+res.tot+(ans1.rc==res.rc)};
        }
        else{
            ans2={res.lc,ans2.rc,0,ans2.tot+res.tot+(ans2.lc==res.rc)};
        }
        x=fa[top[x]];
    }
    if(deep[x]<deep[y]){
        isans1^=1;
        swap(x,y);
    }
    tree res=ask(1,1,n,id[y],id[x]);
    if(isans1){
        ans1={ans1.lc,res.lc,0,ans1.tot+res.tot+(ans1.rc==res.rc)};
    }
    else{
        ans2={res.lc,ans2.rc,0,ans2.tot+res.tot+(ans2.lc==res.rc)};
    }
    return ans1.tot+ans2.tot+(ans1.rc==ans2.lc);
}
void clear(){
    idcnt=0;
    dfncnt=0;
    clearzero(t);
    clearzero(wnew);
    clearzero(id);
    clearzero(fa);
    clearzero(deep);
    clearzero(size);
    clearzero(maxson);
    clearzero(top);
    clearzero(dfn);
    for(int i=1;i<=n;++i){
        e[i].clear();
    }
}
int main(){
    int t;cin>>t;
    while(t--){
        cin>>n>>m;
        clear();
        for(int i=1;i<=n-1;++i){
            int x,y;
            cin>>x>>y;
            e[x].push_back(y);
            e[y].push_back(x);
        }
        dfs1(1,0);
        dfs2(1,1);
        iota(wnew+1,wnew+n+1,1);
        build(1,1,n);
        for(int i=1;i<=m;++i){
            int opt,x,y;
            cin>>opt>>x>>y;
            if(opt==1){
                change_path(x,y,i);
            }
            else{
                cout<<ask_path(x,y)<<'\n';
            }
        }
    }
}