O - Snacks（DFS序2）

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

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

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

Input

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

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

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

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

接下来mm行，有两种操作：0 x y，表示编号为x的零食机的价值变为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

题目大意：

n个零食机 n-1条边

两个操作：0 a b 是标号x的另实际价值变为b ； 1 a 查询从0号开始到a的最大价值和

思路概括：

求出dfs序后用线段树去做修改然后区间求和

#pragma comment(linker, "/STACK:1024000000,1024000000")
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<bitset>
#include<cassert>
#include<cctype>
#include<cmath>
#include<cstdlib>
#include<ctime>
#include<deque>
#include<iomanip>
#include<list>
#include<map>
#include<queue>
#include<set>
#include<stack>
#include<vector>
using namespace std;
typedef long long ll;
#define int ll
typedef long double ld;
#define ios ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
#define mem(a, b) memset(a, b, sizeof(a))
const double pi = acos(-1.0);
const double eps = 1e-6;
const ll mod = 1e9 + 7;
const int inf = 0x3f3f3f3f;
const ll INF = 0x3f3f3f3f3f3f3f3f;
const int maxn = 1e5 + 5;
int w[maxn], dis[maxn], head[maxn];
int in[maxn], out[maxn];
int cnt;
int cntt;
int path[maxn];
int n, m;
struct node
{
    int to, next;
}edge[maxn * 4];
void add_edge(int u, int v)
{
    edge[cnt].to = v;
    edge[cnt].next = head[u];
    head[u] = cnt++;
}
void dfs(int u, int fa)
{
    in[u] = ++cntt;
    path[cntt] = u;
    for(int i=head[u];i!=-1;i=edge[i].next)
    {
        int v = edge[i].to;
        if(v == fa) continue;
        dis[v] = dis[u] + w[v];
        dfs(v, u);
    }
    out[u] = cntt;
}
struct nodd
{
    int sum, lazy;
}tree[maxn * 4];
void build(int l, int r, int k)
{
    tree[k].sum = 0;
    tree[k].lazy = 0;
    if(l == r)
    {
        tree[k].sum = dis[path[l]];
        return ;
    }
    int mid = (l + r) >> 1;
    build(l, mid, k << 1);
    build(mid + 1, r,  k << 1|1);
    tree[k].sum = max(tree[k* 2].sum , tree[k * 2 +1].sum);
}
void pushdown(int k)
{
    tree[k * 2].sum += tree[k].lazy;
    tree[k * 2 + 1].sum += tree[k].lazy;
    tree[k * 2].lazy += tree[k].lazy;
    tree[k * 2 + 1].lazy += tree[k].lazy;
    tree[k].lazy = 0;
}
void updata(int L, int R, int val, int l, int r, int k)
{
    if(L <= l && R >= r)
    {
        tree[k].sum += val;
        tree[k].lazy += val;
        return ;
    }
    if(tree[k].lazy) pushdown(k);
    int mid = (l + r) >> 1;
    if(mid >= L) updata(L, R, val, l, mid, k << 1);
    if(mid < R) updata(L, R, val, mid + 1, r, k << 1 | 1);
    tree[k].sum = max(tree[k << 1].sum, tree[k << 1|1].sum);
}
ll query(int L, int R, int l, int r, int k)
{
    if(L <= l && R >= r)
    {
        return tree[k].sum;
    }
    if(tree[k].lazy) pushdown(k);
    int mid = (l + r) >> 1;
    ll ans = -INF;
    if(mid >= L) ans = max(ans, query(L, R, l, mid, k << 1));
    if(mid < R) ans = max(ans, query(L, R, mid + 1, r, k << 1|1));
    return ans;
}
signed main()
{
    ios;
    int t;
    int k = 1;
    cin >> t;
    while(t--)
    {
        cnt = 0;
        cntt = 0;
        mem(head, -1);
        mem(dis, 0);
        cin >> n >> m;
        for(int i=1;i<n;i++)
        {
            int u, v;
            cin >> u >> v;
            add_edge(u, v);
            add_edge(v, u);
        }
        for(int i=0;i<n;i++)
        {
            cin >> w[i];
        }
        dis[0] = w[0];
        dfs(0, -1);
        build(1, n, 1);
        cout << "Case #" << k++ << ":" << endl;
        while(m--)
        {
            int a, b, c;
            cin >> a;
            if(!a)
            {
                cin >> b >> c;
                updata(in[b], out[b], c - w[b], 1, n, 1);
                w[b] = c;
            }
            else
            {
                cin >> b;
                cout << query(in[b], out[b], 1, n, 1) << endl;
            }
        }
    }
    return 0;
}