51nod 1819 黑白树 V2 树链剖分维护轻儿子信息+线段树

题意

给定一棵以1为根的有根树，点可能是黑色或白色，操作如下。
1. 选定一个点x，将x的子树中所有到x的距离为奇数的点的颜色反转。
2. 选定一个点x，将点x的颜色反转。
3. 选定一个点x，询问所有黑点y（包括点x）与点x的lca（最近公共祖先）的和。
n,m<=200000

分析

这可能是我写过的最长的一道树链剖分。。。

先附上官方的题解：
考虑用树链剖分维护答案。
线段树上要维护一些信息。
sum[i][j] 考虑令w[x][i][j]为(x的轻儿子的子树中满足dep[v] mod 2=i,col[v]=j的节点v的个数)*x，sum[i][j]即线段树节点代表的区间中的w[x][i][j]之和。
cnt[x][i][j] 表示x的子树中满足dep[v] mod 2=i,col[v]=j的节点v的个数
col[x]表示点x的颜色
tag[i] 表示对满足dep[x] mod 2=i的节点的翻转标记
核心思想是询问时经过重链的答案直接统计，走轻边时可以暴力在线段树上询问

然后说一说自己的感受。
上面要维护的东西都比较显然，但一开始想的是每个点维护其整棵子树的贡献而不是轻儿子的贡献，这样的话就要多维护一些东西而且麻烦很多。
这告诉我们以后碰到某些要维护子树贡献的题的时候，可以考虑每个点只维护其轻儿子的贡献，然后走轻边的时候暴力查询。

代码

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<algorithm>
using namespace std;

typedef long long LL;

const int N=200005;

int n,m,cnt,last[N],dep[N],fa[N],dr[N],col[N],bs[N][2][2],hs[N][2][2],size[N],pos[N],mx[N],sz,bel[N],top[N],ds[N][2];
struct edge{int to,next;}e[N*2];
struct tree{int s[2][2];LL w[2][2];bool tag[2];}t[N*4];

int read()
{
    int x=0,f=1;char ch=getchar();
    while (ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while (ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}

void addedge(int u,int v)
{
    e[++cnt].to=v;e[cnt].next=last[u];last[u]=cnt;
    e[++cnt].to=u;e[cnt].next=last[v];last[v]=cnt;
}

void dfs1(int x)
{
    size[x]=1;dep[x]=dep[fa[x]]+1;dr[x]=dep[x]%2;bs[x][dr[x]][col[x]]++;ds[x][dr[x]]++;
    for (int i=last[x];i;i=e[i].next)
    {
        if (e[i].to==fa[x]) continue;
        fa[e[i].to]=x;
        dfs1(e[i].to);
        size[x]+=size[e[i].to];
        for (int j=0;j<=1;j++)
            for (int k=0;k<=1;k++)
                bs[x][j][k]+=bs[e[i].to][j][k];
        ds[x][0]+=ds[e[i].to][0];
        ds[x][1]+=ds[e[i].to][1];
    }
}

void dfs2(int x,int chain)
{
    pos[x]=mx[x]=++sz;bel[sz]=x;top[x]=chain;hs[x][dr[x]][col[x]]++;int k=0;
    for (int i=last[x];i;i=e[i].next)
        if (e[i].to!=fa[x]&&size[e[i].to]>size[k]) k=e[i].to;
    if (!k) return;
    dfs2(k,chain);
    for (int i=last[x];i;i=e[i].next)
        if (e[i].to!=fa[x]&&e[i].to!=k)
        {
            dfs2(e[i].to,e[i].to);
            for (int j=0;j<=1;j++)
                for (int k=0;k<=1;k++)
                    hs[x][j][k]+=bs[e[i].to][j][k];
        }
    mx[x]=sz;
}

void updata(int d)
{
    for (int i=0;i<=1;i++)
        for (int j=0;j<=1;j++)
        {
            t[d].s[i][j]=t[d*2].s[i][j]+t[d*2+1].s[i][j];
            t[d].w[i][j]=t[d*2].w[i][j]+t[d*2+1].w[i][j];
        }
}

void pushdown(int d)
{
    if (t[d].tag[0])
    {
        t[d*2].tag[0]^=1;t[d*2+1].tag[0]^=1;t[d].tag[0]^=1;
        swap(t[d*2].s[0][0],t[d*2].s[0][1]);
        swap(t[d*2].w[0][0],t[d*2].w[0][1]);
        swap(t[d*2+1].s[0][0],t[d*2+1].s[0][1]);
        swap(t[d*2+1].w[0][0],t[d*2+1].w[0][1]);
    }
    if (t[d].tag[1])
    {
        t[d*2].tag[1]^=1;t[d*2+1].tag[1]^=1;t[d].tag[1]^=1;
        swap(t[d*2].s[1][0],t[d*2].s[1][1]);
        swap(t[d*2].w[1][0],t[d*2].w[1][1]);
        swap(t[d*2+1].s[1][0],t[d*2+1].s[1][1]);
        swap(t[d*2+1].w[1][0],t[d*2+1].w[1][1]);
    }
}

void build(int d,int l,int r)
{
    if (l==r)
    {
        int x=bel[l];
        t[d].s[dr[x]][col[x]]=1;
        for (int i=0;i<=1;i++)
            for (int j=0;j<=1;j++)
                t[d].w[i][j]=(LL)hs[x][i][j]*x;
        return;
    }
    int mid=(l+r)/2;
    build(d*2,l,mid);build(d*2+1,mid+1,r);
    updata(d);
}

void modify(int d,int l,int r,int x,int c,int k)
{
    if (l<r) pushdown(d);
    if (l==r)
    {
        t[d].w[k][c]+=bel[l];t[d].w[k][c^1]-=bel[l];
        return;
    }
    int mid=(l+r)/2;
    if (x<=mid) modify(d*2,l,mid,x,c,k);
    else modify(d*2+1,mid+1,r,x,c,k);
    updata(d);
}

void change(int d,int l,int r,int x)
{
    if (l<r) pushdown(d);
    if (l==r)
    {
        int k=dr[bel[l]];
        swap(t[d].s[k][0],t[d].s[k][1]);
        return;
    }
    int mid=(l+r)/2;
    if (x<=mid) change(d*2,l,mid,x);
    else change(d*2+1,mid+1,r,x);
    updata(d);
}

bool findc(int d,int l,int r,int x)
{
    if (l<r) pushdown(d);
    if (l==r) return t[d].s[dr[bel[l]]][0]?0:1;
    int mid=(l+r)/2;
    if (x<=mid) return findc(d*2,l,mid,x);
    else return findc(d*2+1,mid+1,r,x);
}

void modify(int x)
{
    change(1,1,n,pos[x]);int c=findc(1,1,n,pos[x]),k=dr[x];
    while (x)
    {
        modify(1,1,n,pos[x],c,k);
        x=fa[top[x]];
    }
}

int find(int d,int l,int r,int x,int y)
{
    if (l<r) pushdown(d);
    if (l==x&&r==y) return t[d].s[0][1]+t[d].s[1][1];
    int mid=(l+r)/2;
    if (y<=mid) return find(d*2,l,mid,x,y);
    else if (x>mid) return find(d*2+1,mid+1,r,x,y);
    else return find(d*2,l,mid,x,mid)+find(d*2+1,mid+1,r,mid+1,y);
}

int find(int d,int l,int r,int x,int y,int k)
{
    if (l<r) pushdown(d);
    if (l==x&&r==y) return t[d].s[k][1];
    int mid=(l+r)/2;
    if (y<=mid) return find(d*2,l,mid,x,y,k);
    else if (x>mid) return find(d*2+1,mid+1,r,x,y,k);
    else return find(d*2,l,mid,x,mid,k)+find(d*2+1,mid+1,r,mid+1,y,k);
}

LL query(int d,int l,int r,int x,int y)
{
    if (l<r) pushdown(d);
    if (l==x&&r==y) return t[d].w[0][1]+t[d].w[1][1];
    int mid=(l+r)/2;
    if (y<=mid) return query(d*2,l,mid,x,y);
    else if (x>mid) return query(d*2+1,mid+1,r,x,y);
    else return query(d*2,l,mid,x,mid)+query(d*2+1,mid+1,r,mid+1,y);
}

LL query(int x)
{
    LL ans=(LL)x*find(1,1,n,pos[x],mx[x]);
    while (x>1)
    {
        if (x!=top[x]) ans+=query(1,1,n,pos[top[x]],pos[x]-1),x=top[x];
        else ans+=(LL)fa[x]*(find(1,1,n,pos[fa[x]],mx[fa[x]])-find(1,1,n,pos[x],mx[x])),x=fa[x];
    }
    return ans;
}

void rev(int d,int l,int r,int x,int y,int k)
{
    if (l<r) pushdown(d);
    if (l==x&&r==y)
    {
        swap(t[d].s[k][0],t[d].s[k][1]);
        swap(t[d].w[k][0],t[d].w[k][1]);
        t[d].tag[k]^=1;
        return;
    }
    int mid=(l+r)/2;
    if (y<=mid) rev(d*2,l,mid,x,y,k);
    else if (x>mid) rev(d*2+1,mid+1,r,x,y,k);
    else rev(d*2,l,mid,x,mid,k),rev(d*2+1,mid+1,r,mid+1,y,k);
    updata(d);
}

void modify(int d,int l,int r,int x,int bs,int ws,int k)
{
    if (l<r) pushdown(d);
    if (l==r)
    {
        t[d].w[k][1]+=(LL)ws*bel[l]-(LL)bs*bel[l];
        t[d].w[k][0]+=(LL)bs*bel[l]-(LL)ws*bel[l];
        return;
    }
    int mid=(l+r)/2;
    if (x<=mid) modify(d*2,l,mid,x,bs,ws,k);
    else modify(d*2+1,mid+1,r,x,bs,ws,k);
    updata(d);
}

int main()
{
    n=read();m=read();
    for (int i=1;i<=n;i++) col[i]=read();
    for (int i=1;i<n;i++)
    {
        int x=read(),y=read();
        addedge(x,y);
    }
    dfs1(1);
    dfs2(1,1);
    build(1,1,n);
    while (m--)
    {
        int op=read(),x=read();
        if (op==1)
        {
            int k=dr[x]^1,bs=find(1,1,n,pos[x],mx[x],k),ws=ds[x][k]-bs;
            rev(1,1,n,pos[x],mx[x],k);
            while (top[x]!=1)
            {
                x=fa[top[x]];
                modify(1,1,n,pos[x],bs,ws,k);
            }
        }
        else if (op==2) modify(x);
        else printf("%lld\n",query(x));
    }
    return 0;
}