HDU 5692 Snacks 好题：dfs序+线段树维护区间最值

题目链接：Snacks

最近想学树链剖分，但无奈，前置技能还不会，dfs序还没搞懂是什么玩意，就上B站学习了一波，无奈太菜了，也没听太懂，就了解了个大概，想着去刷道题，练一练，这不，找到了这道 HDU 5692 Snacks，这题真的是好题，费了我不少时间，才搞定， 可能是在家效率太低，可能最近对头发的保养很重视，一天到晚坐在电脑面前学习对目前的我来说是不太可能了。

WA了20来发：

上干货：以这题为例

首先对于这道题我们不难发现，我们要求从0点出发，经过点q，的最大路径和多少，从0点经过点q的点有很多条，即以点q为根，的子节点数量，我们只需要将从0点到所有点的权值和求出来即可眼观得经过点p的那条路径的权值和最大

未经处理的树形图：

经处理的树形图：

我们先不考虑修改，只考虑询问，这样不就很直观了！但是我们要怎么实现最大值的询问呢，这里dfs序的用处就来了，我们要求的区间，其实就是以p节点和它的所有子节点中哪一个权值最大，而dfs序，其实就是按照dfs的顺序来的，而dfs的性质：一定是把某一节点的根节点询问完后，再跳到另一个节点

以上图为例：

第一种dfs序：0 1 2 3 4 5

第二种dfs序：0 1 2 2 1 3 4 4 5 5 3 0

讲解第一种

假如我要询问经过1的区间，这里我们如何询问，其实很简单我们只需要用一个in[]数组记录每个节点的时间戳，再用一个sizx[]数组记录以每个节点为根的节点数量大小，然后我们想询问的区间就出来了，是(in[1],in[1]+sizx[1]-1)

讲解第二种

假如我们还是询问经过1的区间，这里我们可以开一个in[]数组记录进入1的时间戳，再开一个数组out[]记录离开1的时间戳，这里(in[1],out[1])就是我们想要询问的区间

注意点：

第二种只有在数据量很小，而且空间时间充足的情况下，使用，不然就会疯狂TLE，MLE， Runtime Error，上图WA就是典型，所以最好用第一种

接下来就是线段树的常规操作了

既然我们目前都已经知道要问的区间了，那么不就是一个裸的线段树问题么，相信线段树都会，这里就不讲解了

修改操作

这里的修改涉及区间修改，那么就用一个懒人标记去修改就行了，因为是直接把最初的节点权值变成某值，我们只需要知道他们之间的差值是多少，在一开始处理过的树上进行区间修改就可

AC代码：

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<vector>
using namespace std;
#define ll long long
const ll maxn=1e5+10;
vector<ll>vec[maxn];
ll cnt;
ll dp[maxn*2],in[maxn],sizx[maxn*2],df[maxn*2];
ll a[maxn];
void init()
{
    cnt=0;
    memset(dp,0,sizeof(dp));
    memset(vec,0,sizeof(vec));
}
void dfs(ll u,ll fa)
{
    in[u]=++cnt;
    sizx[u]=1;
    df[cnt]=u;
    if(fa!=-1)
        dp[u]+=dp[fa];
    for(ll i=0; i<vec[u].size(); i++)
    {
        ll v=vec[u][i];
        if(v!=fa)
        {
            dfs(v,u);
            sizx[u]+=sizx[v];
        }
    }
}
struct node
{
    ll l,r,maxx,lazy;
} tr[maxn*4];
void pushup(ll k)
{
    tr[k].maxx=max(tr[k<<1].maxx,tr[k<<1|1].maxx);
}
void pushdown(ll k)
{
    if(tr[k].l==tr[k].r)
        return;
    if(tr[k].lazy)
    {
        tr[k<<1].maxx+=tr[k].lazy;
        tr[k<<1].lazy+=tr[k].lazy;
        tr[k<<1|1].maxx+=tr[k].lazy;
        tr[k<<1|1].lazy+=tr[k].lazy;
        tr[k].lazy=0;
    }
}
void build(ll k,ll l,ll r)
{
    tr[k].l=l,tr[k].r=r;
    tr[k].lazy=0;
    if(l==r)
    {
        tr[k].maxx=dp[df[l]];
        return;
    }
    ll mid=l+r>>1;
    build(k<<1,l,mid);
    build(k<<1|1,mid+1,r);
    pushup(k);
}
void modify(ll k,ll l,ll r,ll w)
{
    if(tr[k].l>=l&&tr[k].r<=r)
    {
        tr[k].lazy+=w;
        tr[k].maxx+=w;
        return ;
    }
    pushdown(k);
    ll mid=tr[k].l+tr[k].r>>1;
    if(mid>=r)
    {
        modify(k<<1,l,r,w);
    }
    else if(mid<l)
    {
        modify(k<<1|1,l,r,w);
    }
    else
    {
        modify(k<<1,l,mid,w);
        modify(k<<1|1,mid+1,r,w);
    }
    pushup(k);
}
ll query(ll k,ll l,ll r)
{
    if(tr[k].l>=l&&tr[k].r<=r)
    {
        return tr[k].maxx;
    }
    pushdown(k);
    ll mid=tr[k].l+tr[k].r>>1;
    if(mid>=r)
    {
        return query(k<<1,l,r);
    }
    else if(mid<l)
    {
        return query(k<<1|1,l,r);
    }
    return max(query(k<<1,l,mid),query(k<<1|1,mid+1,r));

}
int main()
{
    ll t,d=0;
    scanf("%lld",&t);
    while(t--)
    {
        init();
        cnt=0;
        ll n,u,v,m;
        scanf("%lld %lld",&n,&m);
        for(ll i=1; i<n; i++)
        {
            scanf("%lld %lld",&u,&v);
            vec[u].push_back(v);
            vec[v].push_back(u);
        }
        for(ll i=0; i<n; i++)
        {
            scanf("%lld",&dp[i]);
            a[i]=dp[i];
        }
        dfs(0,-1);
        build(1,1,cnt);
        printf("Case #%lld:\n",++d);
        while(m--)
        {
            ll k,op;
            scanf("%lld",&op);
            if(op==1)
            {
                scanf("%lld",&k);
                printf("%lld\n",query(1,in[k],in[k]+sizx[k]-1));
            }
            else
            {
                ll pos,val;
                scanf("%lld %lld",&pos,&val);
                modify(1,in[pos],in[pos]+sizx[pos]-1,val-a[pos]);
                a[pos]=val;
            }
        }
    }
}