bzoj 1036 [ZJOI2008]树的统计Count 题解（树链剖分）

原题链接：
洛谷：点我QωQ
bzoj：点我QωQ

题意简述

仍然很模板。。。
给一个树，要支持三种操作：路径求最大，路径求和，单点修改。

数据

输入

先是一个正整数$n$和接下来$n-1$行每行两个数$u,v$表示$u$到$v$有一个边。
然后一行$n$个正整数，第$i$个表示点$i$的初始权值。
然后有一个正整数$q$，表示操作个数。
接下来$q$行每行描述一个操作。
操作有三种形式，

1. $QMAX$ $x$ $y$ ：表示求$x$到$y$路径中点权最大的
2. $QSUM$ $x$ $y$：表示求$x$到$y$路径上的点权和
3. $Change$ $p$ $x$：表示将点$p$的权值改为$x$。

输出

对于每个以$QMAX$或$QSUM$形式给出的询问，输出答案。

样例

输入

4
1 2
2 3
4 1
4 2 1 3
12
QMAX 3 4
QMAX 3 3
QMAX 3 2
QMAX 2 3
QSUM 3 4
QSUM 2 1
CHANGE 1 5
QMAX 3 4
CHANGE 3 6
QMAX 3 4
QMAX 2 4
QSUM 3 4

输出

4
1
2
2
10
6
5
6
5
16

思路

这个是树链剖分的板子题吧？
原本看只有单点修改，还以为能用$BIT$，但是。。。那样不好求最大。。。
不过线段树也会比较简单，因为不用打$lazytag$了，就是要多维护一点东西。

对了，提一下做树链剖分题的小技巧：你先看在序列上会不会做，在用分块的思路对应到树上。

代码：

#include<bits/stdc++.h>
using namespace std;
namespace Flandle_Scarlet
{
    #define N 200100
    #define int long long
    class Graph//图
    {
        public:
            int head[N];
            int EdgeCount;
            struct Edge
            {
                int To,Label,Next;
            }Ed[N];
 
            void clear()
            {
                memset(Ed,-1,sizeof(Ed));
                memset(head,-1,sizeof(head));
                EdgeCount=0;
            }
            void AddEdge(int u,int v,int w)
            {
                ++EdgeCount;
                Ed[EdgeCount]=(Edge){v,w,head[u]};
                head[u]=EdgeCount;
            }
 
            int Start(int u)
            {
                return head[u];
            }
            int To(int u)
            {
                return Ed[u].To;
            }
            int Label(int u)
            {
                return Ed[u].Label;
            }
            int Next(int u)
            {
                return Ed[u].Next;
            }
    }G;void Add(int u,int v,int w){G.AddEdge(u,v,w);G.AddEdge(v,u,w);}
 
    int n,m,r=1;
    int w[N];
    void R1(int &x)
    {
        x=0;int f=1;char c=getchar();
        while(c<'0' or c>'9') f=(c=='-')?-1:1,c=getchar();
        while(c>='0' and c<='9') x=(x<<1)+(x<<3)+(c^48),c=getchar();
        x=(f==-1)?-x:x;
    }
    void Rarr(int p[N],int len)
    {
        for(int i=1;i<=len;++i)
        {
            R1(p[i]);
        }
    }
    void Input()
    {
        R1(n);
        for(int i=1;i<n;++i)
        {
            int a,b;R1(a),R1(b);
            Add(a,b,1);
        }
        Rarr(w,n);
        R1(m);
    }
 
    bool upmax(int &x,int y){return (y>x)?(x=y,1):0;}
    bool upmin(int &x,int y){return (y<x)?(x=y,1):0;}
    int deep[N],size[N],son[N],fa[N];
    void DFS1(int u,int f)
    {
        deep[u]=(u==r)?1:deep[f]+1;
        fa[u]=f;
        size[u]=1;
 
        son[u]=-1;int Max=-1;
        if (G.Start(u)==-1) return;
        for(int i=G.Start(u);~i;i=G.Next(i))
        {
            int v=G.To(i);
            if (v!=f)
            {
                DFS1(v,u);
                size[u]+=size[v];
                if (upmax(Max,size[v])) son[u]=v;
            }
        }
    }
    int DFSid[N];int cnt=0;
    int top[N];
    int wt[N];
    void DFS2(int u,int topu)
    {
        DFSid[u]=++cnt;
        wt[cnt]=w[u];
        top[u]=topu;
        if (son[u]==-1) return;
 
        DFS2(son[u],topu);
        for(int i=G.Start(u);~i;i=G.Next(i))
        {
            int v=G.To(i);
            if (v!=son[u] and v!=fa[u] and ~v)
            {
                DFS2(v,v);
            }
        }
    }
 
    class SegmentTree//要能求区间最大值以及区间和
    {
        public:
            struct node
            {
                int l,r;
                int s,x;
            }tree[N<<2];
            #define ls index<<1
            #define rs index<<1|1
 
            #define L tree[index].l
            #define R tree[index].r
            #define S tree[index].s
            #define X tree[index].x
 
            #define lL tree[ls].l
            #define lR tree[ls].r
            #define lS tree[ls].s
            #define lX tree[ls].x
 
            #define rL tree[rs].l
            #define rR tree[rs].r
            #define rS tree[rs].s
            #define rX tree[rs].x
            void Update(int index)
            {
                S=(lS+rS);
                X=max(lX,rX);
            }
            void BuildTree(int l,int r,int index)
            {
                L=l,R=r,S=0,X=0xcfcfcfcfcfcfcfcf;//会负数，这里千万要注意！！！
                if (l==r)
                {
                    S=X=wt[l];
                    return;
                }
                int mid=(l+r)>>1;
                BuildTree(l,mid,ls);
                BuildTree(mid+1,r,rs);
                Update(index);
            }
            void AddOne(int x,int index)
            {
                S+=x*(R-L+1);
                X+=x;
            }
            void Add(int p,int x,int index)
            {
                if (p<L or p>R) return;
                if (L==R and L==p) return AddOne(x,index);
                Add(p,x,ls);
                Add(p,x,rs);
                Update(index);
            }
            int QuerySum(int l,int r,int index)
            {
                if (l>R or L>r or l>r) return 0;
                if (l<=L and R<=r) return S;
                return (QuerySum(l,r,ls)+QuerySum(l,r,rs));
            }
            int QueryMax(int l,int r,int index)
            {
                if (l>R or L>r or l>r) return 0xcfcfcfcfcfcfcfcfll;
                if (l<=L and R<=r) return X;
                return max(QueryMax(l,r,ls),QueryMax(l,r,rs));
            }
            #undef ls //index<<1
            #undef rs //index<<1|1
 
            #undef L //tree[index].l
            #undef R //tree[index].r
            #undef S //tree[index].s
            #undef X //tree[index].x
 
            #undef lL //tree[ls].l
            #undef lR //tree[ls].r
            #undef lS //tree[ls].s
            #undef lX //tree[ls].x
 
            #undef rL //tree[rs].l
            #undef rR //tree[rs].r
            #undef rS //tree[rs].s
            #undef rX //tree[rs].x
    }T;
    void BuildCut()
    {
        DFS1(r,-1);
        DFS2(r,-1);
        T.BuildTree(1,n,1);
    }
    void SingleAdd(int u,int x)
    {
        int ori=T.QuerySum(DFSid[u],DFSid[u],1);
        int add=x-ori;
        T.Add(DFSid[u],add,1);
    }
    int PathSum(int u,int v)
    {
        int ans=0;
        while(top[u]!=top[v])//不断分块的思路，将树上问题转换列上问题
        {
            if (deep[top[u]]<deep[top[v]]) swap(u,v);
            ans+=T.QuerySum(DFSid[top[u]],DFSid[u],1);
            u=fa[top[u]];
        }
        if (deep[u]>deep[v]) swap(u,v);
        ans+=T.QuerySum(DFSid[u],DFSid[v],1);
        return ans;
    }
    int PathMax(int u,int v)
    {
        int ans=0xcfcfcfcfcfcfcfcfll;
        while(top[u]!=top[v])
        {
            if (deep[top[u]]<deep[top[v]]) swap(u,v);
            upmax(ans,T.QueryMax(DFSid[top[u]],DFSid[u],1));
            u=fa[top[u]];
        }
        if (deep[u]>deep[v]) swap(u,v);
        upmax(ans,T.QueryMax(DFSid[u],DFSid[v],1));
        return ans;
    }
 
    void Query()
    {
        for(int i=1;i<=m;++i)
        {
            char o[10];scanf("%s",o);
            if (o[1]=='H')
            {
                int u,x;
                R1(u),R1(x);
                SingleAdd(u,x);
            }
            else if (o[1]=='S')
            {
                int u,v;
                R1(u),R1(v);
                printf("%lld\n",PathSum(u,v));
            }
            else if (o[1]=='M')
            {
                int u,v;
                R1(u),R1(v);
                printf("%lld\n",PathMax(u,v));
            }
        }
    }
    void Main()
    {
        G.clear();
        Input();
 
        BuildCut();
        Query();
    }
    #undef N //200100
    #undef int //long long
};
main()
{
    Flandle_Scarlet::Main();
    return 0;
}