[CF165D]Beard Graph

题目

传送门

题解

这类题目，不多说可以直接上树剖板子，时间复杂度 \(\mathcal O(n\log ^2n)\)，此处不作过多赘述，毕竟重点不是这个方法。

实际上我们有比树剖的俩 \(\log\) 更优的解法，但是还是利用线段树。

分析这道题实际要我们干的事是什么：

1. 能够任意改边的颜色；
2. 询问俩点之间的距离，以及俩点路径上黑边的数量；

由于所有的工作都是为询问服务，我们先考虑怎么解决询问。

由于是询问两点之间的距离，以及黑边数量，我们能够联想到 \(lca\)，从 \(lca\) 的角度来说，对于距离是很好解决的，但是黑边数量？我们可以用类似求距离的方法，来求黑边的数量，考虑有这样的一个变换：

\[\text{cnt_black}(u,v)=\text{cnt_black}(u,1)+\text{cnt_black}(v,1)-\text{cnt_black}(lca,1) \]

也就是说，只要我们可以维护一个点到根节点的黑边数量，我们便亦能求得两点间黑边数量，考虑对于一条边 \((u,v)\)（假定 \(v\) 更深），如果这条边变黑，即相当于 \(v\) 子树内部整体到根的黑边数加一，对于黑变白同理，所以我们可以先得到每个点的 \(dfs\) 序，再用线段树维护黑边数即可，时间复杂度 \(\mathcal O(n\log n)\).

代码

#include<cstdio>
#include<algorithm>
using namespace std;

#define rep(i,__l,__r) for(signed i=(__l),i##_end_=(__r);i<=i##_end_;++i)
#define fep(i,__l,__r) for(signed i=(__l),i##_end_=(__r);i>=i##_end_;--i)
#define erep(i,u) for(signed i=tail[u],v=e[i].to;i;i=e[i].nxt,v=e[i].to)
#define writc(a,b) fwrit(a),putchar(b)
#define mp(a,b) make_pair(a,b)
#define ft first
#define sd second
typedef long long LL;
// typedef pair<int,int> pii;
typedef unsigned long long ull;
typedef unsigned uint;
#define Endl putchar('\n')
// #define int long long
// #define int unsigned
// #define int unsigned long long

#define cg (c=getchar())
template<class T>inline void read(T& x){
    char c;bool f=0;
    while(cg<'0'||'9'<c)f|=(c=='-');
    for(x=(c^48);'0'<=cg&&c<='9';x=(x<<1)+(x<<3)+(c^48));
    if(f)x=-x;
}
template<class T>inline T read(const T sample){
    T x=0;char c;bool f=0;
    while(cg<'0'||'9'<c)f|=(c=='-');
    for(x=(c^48);'0'<=cg&&c<='9';x=(x<<1)+(x<<3)+(c^48));
    return f?-x:x;
}
template<class T>void fwrit(const T x){//just short,int and long long
    if(x<0)return (void)(putchar('-'),fwrit(-x));
    if(x>9)fwrit(x/10);
    putchar(x%10^48);
}
template<class T>inline T Max(const T x,const T y){return x<y?y:x;}
template<class T>inline T Min(const T x,const T y){return x<y?x:y;}
template<class T>inline T fab(const T x){return x>0?x:-x;}
inline int gcd(const int a,const int b){return b?gcd(b,a%b):a;}
inline void getInv(int inv[],const int lim,const int MOD){
    inv[0]=inv[1]=1;for(int i=2;i<=lim;++i)inv[i]=1ll*inv[MOD%i]*(MOD-MOD/i)%MOD;
}
inline LL mulMod(const LL a,const LL b,const LL mod){//long long multiplie_mod
    return ((a*b-(LL)((long double)a/mod*b+1e-8)*mod)%mod+mod)%mod;
}

const int maxn=1e5;
const int logmaxn=16;
const int maxsize=maxn<<2;

struct edge{int to,nxt;}e[maxn*2+5];
int tail[maxn+5],ecnt=1;//注意此处 ecnt 从 1 开始
inline void add_edge(const int u,const int v){
    e[++ecnt]=edge{v,tail[u]};tail[u]=ecnt;
    e[++ecnt]=edge{u,tail[v]};tail[v]=ecnt;
}

int n;

/** @brief 记录边下面那个点的原编号*/
int down[maxn+5];

int d[maxn+5],dfn[maxn+5],sz[maxn+5];
int times;

int s[maxn+5];

struct Segment_tre{
    /** @brief 维护单点到根的距离, 如果非叶节点则无意义*/
    int seg[maxsize+5];
    int tag[maxsize+5];
    #define lc (i<<1)
    #define rc (i<<1|1)
    #define mid (l+r>>1)
    #define _lq lc,l,mid
    #define _rq rc,mid+1,r
    void buildtre(const int i=1,const int l=1,const int r=n){
        if(l==r)return seg[i]=s[l],void();
        buildtre(_lq);buildtre(_rq);
    }
    inline void add(const int i,const int x){
        seg[i]+=x,tag[i]+=x;
    }
    inline void pushdown(const int i){
        add(lc,tag[i]),add(rc,tag[i]);
        tag[i]=0;
    }
    void modify(const int L,const int R,const int x,const int i=1,const int l=1,const int r=n){
        if(L<=l && r<=R)return add(i,x);
        if(tag[i])pushdown(i);
        if(L<=mid)modify(L,R,x,_lq);
        if(mid<R)modify(L,R,x,_rq);
    }
    int query(const int p,const int i=1,const int l=1,const int r=n){
        if(l==r)return seg[i];
        if(tag[i])pushdown(i);
        if(p<=mid)return query(p,_lq);
        return query(p,_rq);
    }
}tre;

inline void Init(){
    n=read(1);
    rep(i,1,n-1)add_edge(read(1),read(1));
}

int f[maxn+5][logmaxn+5];

void Dfs(const int u,const int fa){
    d[u]=d[fa]+1,sz[u]=1,dfn[u]=++times;
    f[u][0]=fa;
    rep(j,1,logmaxn)f[u][j]=f[f[u][j-1]][j-1];
    erep(i,u)if(v^fa)down[i>>1]=v,Dfs(v,u),sz[u]+=sz[v];
}

inline void update(int& u,const int up){
    fep(j,logmaxn,0)if(d[f[u][j]]>=up)
        u=f[u][j];
}

inline int getlca(int u,int v){
    if(d[u]<d[v])swap(u,v);
    update(u,d[v]);
    if(u==v)return u;
    fep(j,logmaxn,0)if(f[u][j]^f[v][j])
        u=f[u][j],v=f[v][j];
    return f[u][0];
}

int col[maxn+5];
inline void Get_query(){
    int m=read(1);
    int opt,x,y;
    while(m--){
        opt=read(1),x=read(1);
        if(opt==1){
            if(col[x]==1){
                tre.modify(dfn[down[x]],dfn[down[x]]+sz[down[x]]-1,1);
                col[x]=0;
            }
        }else if(opt==2){
            if(col[x]==0){
                tre.modify(dfn[down[x]],dfn[down[x]]+sz[down[x]]-1,-1);
                col[x]=1;
            }
        }else{y=read(1);
            int lca=getlca(x,y);
            // printf("lca == %d\n",lca);
            // printf("query(dfn[%d]) == %d\n",x,tre.query(dfn[x]));
            // printf("query(dfn[%d]) == %d\n",y,tre.query(dfn[y]));
            // printf("query(dfn[%d]) == %d\n",lca,tre.query(dfn[lca]));
            if(tre.query(dfn[x])+tre.query(dfn[y])-2*tre.query(dfn[lca])==d[x]+d[y]-2*d[lca])writc(d[x]+d[y]-2*d[lca],'\n');
            else writc(-1,'\n');
        }
    }
}

signed main(){
    Init();
    Dfs(1,0);
    rep(i,1,n)s[dfn[i]]=d[i];
    // rep(i,1,n)printf("node %d:>%d %d %d\n",i,dfn[i],sz[i],d[i]);
    // rep(i,1,n-1)printf("down[%d] == %d\n",i,down[i]);
    tre.buildtre();
    Get_query();
    return 0;
}