BZOJ 4034浅谈树链剖分及线段树维护

世界真的很大
这道题还是很良心的
上来就说是数据结构的题
这类题的特点是代码量大，叙述简单，支持修改和查询，数据规模在10^5左右
还是先看一下题：
description：

有一棵点数为 N 的树，以点 1 为根，且树点有边权。然后有 M 个
操作，分为三种：
操作 1 ：把某个节点 x 的点权增加 a 。
操作 2 ：把某个节点 x 为根的子树中所有点的点权都增加 a 。
操作 3 ：询问某个节点 x 到根的路径中所有点的点权和。

input

第一行包含两个整数 N, M 。表示点数和操作数。接下来一行 N 个整数，表示树中节点的初始权值。接下来 N-1 
行每行三个正整数 fr, to ， 表示该树中存在一条边 (fr, to) 。再接下来 M 行，每行分别表示一次操作。其中
第一个数表示该操作的种类（ 1-3 ） ，之后接这个操作的参数（ x 或者 x a ） 。

output

对于每个询问操作，输出该询问的答案。答案之间用换行隔开。

对于树上的路径问题或子树大小的维护，且这棵树的结构是不改变的，很容易想到树链剖分或DFS序来维护线段树
遗憾的是这道题两种方法都可以
DFS序一般还是比较熟悉了，所以来尝试一下树链剖分的写法
思路上没什么难度主要是在代码上
树链剖分的重链有一个神奇的性质就是他们的DFS序是连续的
可以用线段树维护DFS序
子树操作时，因为子树的所有点的DFS序都在子树根节点的in，out里，所以直接区间修改就行了
查询是从点到它所属的重链，区间查询，累加起来一直到根节点，细节处理需要注意
完整代码：

#include<stdio.h>
#include<algorithm>
using namespace std;
typedef long long dnt;
struct node
{
    dnt sum,flag;
    node *ls,*rs;
    void pushdown(int lf,int rg)
    {
        if(flag)
        {
            int mid=(lf+rg)>>1;
            ls->flag+=flag;
            ls->sum+=( dnt ) (mid-lf+1)*flag;
            rs->flag+=flag;
            rs->sum+=( dnt ) (rg-mid)*flag;
            flag=0;
        }
    }
    void update()
    {
        sum=ls->sum+rs->sum;
    }
}pool[800010],*tail=pool,*root;

struct edge
{
    int v,last;
}ed[400010];

int num=0,idx=0,n,m;
int head[400010],in[400010],out[400010],re[400010],fa[400010];
int son[400010],siz[400010],top[400010],a[400010];

void add(int u,int v)
{
    num++;
    ed[num].v=v;
    ed[num].last=head[u];
    head[u]=num;
}

node* build(int lf,int rg)
{
    node *nd=++tail;
    if(lf==rg)
    {
        nd->flag=0;
        nd->sum=a[re[lf]];
        return nd;
    }
    int mid=(lf+rg)>>1;
    nd->ls=build(lf,mid);
    nd->rs=build(mid+1,rg);
    nd->update();
    return nd;
}

void dfs1(int u)
{
    siz[u]=1;
    for(int i=head[u];i;i=ed[i].last)
    {
        int v=ed[i].v;
        if(v==fa[u]) continue ;
        fa[v]=u;
        dfs1(v);
        siz[u]+=siz[v];
        if(siz[v]>siz[son[u]]) son[u]=v;
    }
}

void dfs2(int u,int tp)
{
    in[u]=++idx;
    re[idx]=u;
    top[u]=tp;
    if(son[u]) dfs2(son[u],tp);
    for(int i=head[u];i;i=ed[i].last)
    {
        int v=ed[i].v;
        if(v==fa[u] || v==son[u]) continue ;
        dfs2(v,v);
    }
    out[u]=idx;
}

void buildcp()
{
    fa[1]=1;
    dfs1(1);
    idx=0;
    dfs2(1,1);
}

void modify(node* nd,int lf,int rg,int L,int R,int delta)
{
    if(L<=lf&&rg<=R)
    {
        nd->sum+=( dnt ) (rg-lf+1)* delta;
        nd->flag+=delta;
        return ;
    }
    int mid=(lf+rg)>>1;
    nd->pushdown(lf,rg);
    if(L<=mid) modify(nd->ls,lf,mid,L,R,delta);
    if(R>mid) modify(nd->rs,mid+1,rg,L,R,delta);
    nd->update();
    return ;
}

dnt query(node* nd,int lf,int rg,int L,int R)
{
    if(L<=lf&&rg<=R)
    {
        return nd->sum;
    }
    int mid=(lf+rg)>>1;
    dnt rt=0;
    nd->pushdown(lf,rg);
    if(L<=mid) rt+=query(nd->ls,lf,mid,L,R);
    if(R>mid) rt+=query(nd->rs,mid+1,rg,L,R);
    return rt;
}

dnt qu(int u)
{
    dnt rt=0;
    while(top[u]!=1)
    {   
        int L=in[top[u]],R=in[u];
        if(L>R) swap(L,R);
        if(L&&R)
        rt+=query(root,1,idx,L,R);
        u=fa[top[u]];
    }
    rt+=query(root,1,idx,1,in[u]);
    return rt;
}

int main()
{
    scanf("%d%d",&n,&m);
    for(int i=1;i<=m;i++)
        scanf("%d",&a[i]);
    for(int i=1;i<n;i++)
    {
        int u,v;
        scanf("%d%d",&u,&v);
        add(u,v);
        add(v,u);
    }
    buildcp();
    root=build(1,idx);
    for(int i=1;i<=m;i++)
    {
        int opt,u,delta;
        scanf("%d",&opt);
        if(opt==1)
        {
            scanf("%d%d",&u,&delta);
            modify(root,1,idx,in[u],in[u],delta);
        }
        else if(opt==2)
        {
            scanf("%d%d",&u,&delta);
            modify(root,1,idx,in[u],out[u],delta);
        }
        else
        {
            scanf("%d",&u);
            printf("%lld\n",qu(u));
        }
    }
    return 0;
}

嗯，就是这样