hdu 5692 Snacks (DFS序+线段树区间更新)

题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=5692

题目：

百度科技园内有n个零食机，零食机之间通过n−1条路相互连通。每个零食机都有一个值v，表示为小度熊提供零食的价值。 

由于零食被频繁的消耗和补充，零食机的价值vv会时常发生变化。小度熊只能从编号为0的零食机出发，并且每个零食机至多经过一次。另外，小度熊会对某个零食机的零食有所偏爱，要求路线上必须有那个零食机。 

为小度熊规划一个路线，使得路线上的价值总和最大。 

Input

输入数据第一行是一个整数T(T≤10)，表示有TT组测试数据。 

对于每组数据，包含两个整数n,m(1≤n,m≤100000)，表示有nn个零食机，mm次操作。 

接下来n−1行，每行两个整数x和y(0≤x,y<n)，表示编号为x的零食机与编号为y的零食机相连。 

接下来一行由nn个数组成，表示从编号为0到编号为n−1的零食机的初始价值v(|v|<100000)。 

接下来mm行，有两种操作：0 x y，表示编号为xx的零食机的价值变为y；1 x，表示询问从编号为0的零食机出发，必须经过编号为x零食机的路线中，价值总和的最大值。 

本题可能栈溢出，辛苦同学们提交语言选择c++，并在代码的第一行加上： 

`#pragma comment(linker, "/STACK:1024000000,1024000000") `

Output

对于每组数据，首先输出一行”Case #?:”，在问号处应填入当前数据的组数，组数从1开始计算。 

对于每次询问，输出从编号为0的零食机出发，必须经过编号为xx零食机的路线中，价值总和的最大值。 

Sample Input

1
6 5
0 1
1 2
0 3
3 4
5 3
7 -5 100 20 -5 -7
1 1
1 3
0 2 -1
1 1
1 5

Sample Output

Case #1:
102
27
2
20

题目分析：其实就是求一棵子树x里到0点路径权值和最大的点的那个权值和，因为是对一棵子树的所有值，所以容易想到用DFS序来处理，改变x点权值则其子树所有点到0点的路径权值和都要更新，这样就变成区间更新求最值问题，线段树搞一下就可以了，本题巧妙的将DFS序和线段树结合在一起。

太巧妙了，转化为线段树，进行区间更新和最大值的求解。

AC代码：够了，找了一天的错误，没想到是 lazy 用long long 型。

最后还是zxp大佬看了一下，说的.还有就是C++就会WA，G++就AC了

#pragma comment(linker, "/STACK:1024000000,1024000000")//注意用懒惰标记
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>
#define ll long long
using namespace std;
ll const INF = 1e19;
int const MAX = 1e5+10;
int n, m;
ll a[MAX], dis[MAX];
int l[MAX], r[MAX], nd[MAX], num;
vector<int>v[MAX];
struct node{
	int right;
	int left;
	ll lazy;
	ll sum;
}f[4*MAX];
void DFS(int u, int fa)//遍历每个点到根节点的距离，并转化为线段树区间问题
{
    num ++;
    l[u] = num;
    nd[num] = u;//区间与树上的节点对应起来，建树时用到
    int cnt=v[u].size() ;
    for(int i = 0; i<cnt; i++)
    {
        int c = v[u][i];
        if(c != fa)
        {
            dis[c] = dis[u] + a[c];
            DFS(c, u);
        }
    }
    r[u] = num;
}
void PushUp(int rt)
{
    f[rt].sum  = max(f[rt << 1].sum , f[rt << 1 | 1].sum );
    return;
}
void PushDown(int rt)
{
    if(f[rt].lazy )
    {
        f[rt << 1].sum  += f[rt].lazy ;
        f[rt << 1 | 1].sum  += f[rt].lazy ;
        f[rt << 1].lazy += f[rt].lazy ;
        f[rt << 1 | 1].lazy  += f[rt].lazy ;
        f[rt].lazy  = 0;
    }
    return;
}
void Build(int l, int r, int rt)
{
    f[rt].lazy  = 0;f[rt].left =l;f[rt].right =r;
    if(l == r)
    {
        f[rt].sum  = dis[nd[l]];
        return;
    }
    int mid = (l + r) >> 1;
    Build(l,mid,rt<<1);
    Build(mid+1,r,rt<<1|1);
    PushUp(rt);
}
void Update(int L, int R, int val,  int rt)
{
    if(L <= f[rt].left  && f[rt].right  <= R)
    {
        f[rt].lazy  += val;
        f[rt].sum  += val;
        return;
    }
    int mid = (f[rt].left  + f[rt].right ) >> 1;
    PushDown(rt);
    if(L <= mid)
        Update(L, R, val, rt<<1);
    if(mid < R)
        Update(L, R, val, rt<<1|1);
    PushUp(rt);
}
ll Query(int L, int R, int rt)
{
    if(L <= f[rt].left  && f[rt].right <= R)
        return f[rt].sum ;
    int mid = (f[rt].left  + f[rt].right ) >> 1;
    PushDown(rt);
    ll ans = -INF;
    if(L <= mid)
        ans = max(ans, Query(L, R, rt<<1));
    if(mid < R)
        ans = max(ans, Query(L, R, rt<<1|1));
    return ans;
}
int main()
{
    int T;
    scanf("%d", &T);
    for(int ca = 1; ca <= T; ca++)
    {
        printf("Case #%d:\n", ca);
        int x, y;
        scanf("%d %d", &n, &m);
        for(int i=0;i<=n;i++)
            v[i].clear() ;
        for(int i = 0; i < n - 1; i++)
        {
            scanf("%d %d", &x, &y);
            x++;y++;
              v[x].push_back(y);
			  v[y].push_back(x);  
        }
        for(int i = 1; i <= n; i++)
            scanf("%I64d", &a[i]);
        dis[1] = a[1];
        num=0;
        DFS(1, 0);
        Build(1, n, 1);
        while(m --)
        {
            int tp, x, y;
            scanf("%d", &tp);
            if(tp == 1)//此时求x的子树中到根结点的最大值
            {
                scanf("%d", &x);
                x++;
                printf("%I64d\n", Query(l[x], r[x], 1 ));//在这个区间内的均是x的子树上的节点
            }
            else
            {
                scanf("%d %d", &x, &y);
                x++;
                Update(l[x], r[x], y - a[x], 1);//更新
                a[x] = y;
            }
        }
    }
    return 0;
}