HDU4897 （树链剖分+线段树）

Problem Little Devil I （HDU4897）

题目大意

　　给定一棵树，每条边的颜色为黑或白，起始时均为白。

　　支持3种操作：

　　　　操作1：将a->b的路径中的所有边的颜色翻转。

　　　　操作2：将所有 有且仅有一个点在a->b的路径中 的边的颜色翻转。

　　　　操作3：询问a->b的路径中的黑色边数量。

解题分析

　　考虑操作1，只需正常的树链剖分+线段树维护即可。用线段树维护每条边，tag_1[i]表示该区间中的黑色边数量。

　　考虑操作2，一个节点相邻的边只可能为重链和轻链，且重链的数目小于等于2。故对于重链每次直接修改。对于轻链，则需要再用一棵线段树来维护每个节点，tag_2[i]表示该点所连接的所有轻链是否需要被翻转。

　　考虑操作3，一条路径中的重链的信息均已存至第一棵线段树中，直接查询即可。对于轻链，还取决于该边的两个端点是否进行过操作2，用tag_2异或一下即可。

eg：轻链a->b ,则该链的颜色为tag_1[a->b] ^ tag_2[a] ^ tag_2[b]

　　简要做法：

　　　　操作1：每次修改一条重链和重链上方的一条轻链，表示这些链的颜色被翻转。

　　　　操作2：每次直接修改一条重链上下方的重链，每个节点记录是否翻转。

　　　　操作3：重链直接查询，轻链异或求得。

　　时间复杂度（Qlog2(n)）

参考程序

　　看起来不大舒服，还是应该写成模板的形式。

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>

#define V 100008
#define E 200008
#define lson l,m,rt<<1
#define rson m+1,r,rt<<1|1

int n,m,Q;
int a[V],size[V],dep[V],fa[V],top[V],w[V],son[V],rank[V];
int tag_1[V << 2],tag_2[V << 2],lazy_1[V << 2],lazy_2[V << 2];

/*-----------------邻接表---------------*/
struct line{
    int u,v,nt;
}eg[E];
int lt[V],summ,cnt;

void adt(int u,int v){
    eg[++summ].u=u; eg[summ].v=v; eg[summ].nt=lt[u]; lt[u]=summ;
}

void add(int u,int v){
    adt(u,v); adt(v,u);
}
/*---------------------------------------*/
/*------------------线段树---------------*/
void pushup(int rt){
    tag_1[rt]=tag_1[rt<<1]+tag_1[rt<<1|1];
}

void pushdown_1(int rt,int m){
    if (lazy_1[rt]){
        tag_1[rt<<1]= (m-m/2) - tag_1[rt<<1];   // wrong 4
        tag_1[rt<<1|1]= (m/2) - tag_1[rt<<1|1];
        lazy_1[rt<<1]^=1;
        lazy_1[rt<<1|1]^=1;
        lazy_1[rt]=0;
    }
}

void pushdown_2(int rt){
    if (lazy_2[rt]){
        tag_2[rt<<1]^=1;
        tag_2[rt<<1|1]^=1;
        lazy_2[rt<<1]^=1;
        lazy_2[rt<<1|1]^=1;
        lazy_2[rt]=0;
    }
}

void build(int l,int r,int rt){
    tag_1[rt]=tag_2[rt]=lazy_1[rt]=lazy_2[rt]=0;
    if (l==r) return;
    int m=(l+r) >> 1;
    build(lson);
    build(rson);
    pushup(rt);
}

void update_1(int L,int R,int l,int r,int rt){
    if (L <= l && r <= R) {
        tag_1[rt]=r-l+1-tag_1[rt];
        lazy_1[rt]^=1;
        return;
    }
    pushdown_1(rt,r-l+1);
    int m = (l + r) >> 1;
    if (L <= m) update_1(L,R,lson);
    if (m <  R) update_1(L,R,rson);
    pushup(rt);

}

void update_2(int L,int R,int l,int r,int rt){
    if (L <= l && r <= R) {
        tag_2[rt]^=1;
        lazy_2[rt]^=1;
        return;
    }
    pushdown_2(rt);
    int m = (l + r) >> 1;
    if (L <= m) update_2(L,R,lson);
    if (m <  R) update_2(L,R,rson);
}

int query_1(int L,int R,int l,int r,int rt){
    if (L <= l && r <= R) {
        return tag_1[rt];
    }
    pushdown_1(rt,r - l + 1);
    int m = (l + r) >> 1;
    int res = 0;
    if (L <= m) res += query_1(L,R,lson);
    if (m <  R) res += query_1(L,R,rson);
    return res;
}

int query_2(int x,int l,int r,int rt){
    if (l==r){
        return tag_2[rt];
    }
    pushdown_2(rt);
    int m= ( l + r ) >> 1;
    if (x <= m) return query_2(x,lson);
    if (m <  x) return query_2(x,rson);
}    

/*---------------------------------------*/
/*----------------树链剖分---------------*/

void dfs1(int u){
    size[u]=1; son[u]=0;
    for (int i=lt[u];i;i=eg[i].nt){
        int v=eg[i].v;
        if (v!=fa[u]){
            fa[v]=u;
            dep[v]=dep[u]+1;
            dfs1(v);
            size[u]+=size[v];
            if (size[v]>size[son[u]]) son[u]=v;
        }
    }
}

void dfs2(int u,int tp,int x){
    top[u]=tp; w[u]=++cnt; rank[cnt]=u;
    if (son[u])     dfs2(son[u],tp,1);
    for (int i=lt[u];i;i=eg[i].nt){
        int v=eg[i].v;
        if (v==son[u] || v==fa[u]) continue;
        dfs2(v,v,2);
    }
}

void init(){
    memset(lt,0,sizeof(lt));
    summ=1; cnt=0;
    scanf("%d",&n);
    for (int i=1;i<n;i++){
        int u,v;
        scanf("%d %d",&u,&v);
        add(u,v);
    }
    dep[1]=1; fa[1]=0; 
    dfs1(1);
    dfs2(1,1,1);
    build(1,n,1);
}
/*---------------------------------------*/
void work_1(int x,int y){
    while (top[x]!=top[y]){
        if (dep[top[x]]<dep[top[y]]) std::swap(x,y);
        update_1(w[top[x]],w[x],1,n,1);
        x=fa[top[x]];
    }
    if (dep[x]>dep[y]) std::swap(x,y);
    update_1(w[x]+1,w[y],1,n,1);  //wrong 2
}

void work_2(int x,int y){
    while (top[x]!=top[y]){
        if (dep[top[x]]<dep[top[y]]) std::swap(x,y);
        update_2(w[top[x]],w[x],1,n,1);
        if (son[x]) update_1(w[son[x]],w[son[x]],1,n,1);
        if (son[fa[top[x]]]==top[x]) update_1(w[top[x]],w[top[x]],1,n,1);
        x=fa[top[x]];
    }
    if (dep[x]>dep[y]) std::swap(x,y);    
    update_2(w[x],w[y],1,n,1); 
    if (son[y]) update_1(w[son[y]],w[son[y]],1,n,1);
    if (son[fa[x]]==x) update_1(w[x],w[x],1,n,1);
}

void work_3(int x,int y){
    int res=0;
    while (top[x]!=top[y]){
        if (dep[top[x]]<dep[top[y]]) std::swap(x,y);
        res+=query_1(w[top[x]]+1,w[x],1,n,1);  //wrong 3
        res+=query_1(w[top[x]],w[top[x]],1,n,1) ^ query_2(w[top[x]],1,n,1) ^ query_2(w[fa[top[x]]],1,n,1); 
        x=fa[top[x]];
    }
    if (dep[x]>dep[y]) std::swap(x,y);;
    res+=query_1(w[x]+1,w[y],1,n,1);
    printf("%d
",res);
}

int main(){
    int T;
    scanf("%d",&T);
    while (T--){
        init();
        scanf("%d",&Q);    
        while (Q--){
            int x,y,z;
            scanf("%d %d %d",&x,&y,&z);
            if (x==1) work_1(y,z);
            if (x==2) work_2(y,z);
            if (x==3) work_3(y,z);
        }
    }
}