Snacks(HDU5692)_snack hdu-优快云博客

本文链接：https://blog.youkuaiyun.com/MALONG11124/article/details/82253128

Problem Description

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

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

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

Input

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

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

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

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

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

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

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

Output

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

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

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

题意：给一颗树，0节点为树根，每个节点有一个权值，然后有两种操作，一种是将x节点权值变为y，一种是给一个节点x，让你从根节点出发，必须经过x节点，问你所能获得的最大的权值是多少，很明显，这个最大的权值一定是根节点到x或者x的子孙节点的最大值，但是如果我们直接查找的话是肯定有问题的，并且还有修改操作，所以我们是肯定不能离线处理的。

思路：可以先对树进行一遍树形dp把根节点到每个节点路径的权值计算出来，然后可以再跑一遍dfs，将树的dfs序求出来，因为dfs的顺序对于节点x他的子孙节点遍历的顺序一定在他后面一段连续的区间，我们可以记录一下进入这个节点和离开这个节点的时间，然后该节点的子孙节点就处于这两个时间之间，这样就把时间和节点的关系连接起来了，然后我们就可以对连续的区间用线段树来维护，对于每个查询，如果是对于x进行查询，我们就查询[in[x], out[x]]区间的最大值，如果是对于x进行修改，我们就修改区间[in[x], out[x]]的值，将整个区间加上某个值。但是这个题涉及线段树的区间修改，需要用到延时标记，我一开始用的是重新开一个数组作为延时标记，但是一直不对，后面把延时标记放到结构体里面就过了，wa了20多发，很迷,都快崩溃了。

AC代码:

#pragma comment(linker, "/STACK:1024000000,1024000000")
#include<iostream>
#include<stdio.h>
#include<algorithm>
#include<vector>
#include<string.h>
using namespace std;
typedef long long LL;
const LL INF = 1e18 + 10;
const int maxn = 1e5 + 10;
vector<int>t[maxn];
LL val[maxn*2], dp[maxn*2], cost[maxn];
int vis[maxn], cnt, in[maxn], out[maxn], dfn[maxn];

void init()
{
    memset(val, 0, sizeof(val));
    memset(dp, 0, sizeof(dp));
    memset(vis, 0, sizeof(vis));
    memset(cost, 0, sizeof(cost));
    memset(dfn, 0, sizeof(dfn));
    memset(in, 0, sizeof(in));
    memset(out, 0, sizeof(out));
    cnt = 0;
    for(int i = 0; i < maxn; i++)
    {
        t[i].clear();
    }
}
void redfs(int x)
{
    dfn[x] = 1;
    for(int i = 0; i < t[x].size(); i++)
    {
        int v = t[x][i];
        if(!dfn[v])
        {
            val[v] += val[x];
            redfs(v);
        }
    }
}
void dfs(int u, int &cnt)
{
    vis[u] = 1;
    in[u] = ++cnt;
    dp[cnt] = val[u];
    for(int i = 0; i < t[u].size(); i++)
    {
        int v = t[u][i];
        if(!vis[v])
        {
            dfs(v, cnt);
        }
    }
    out[u] = cnt;
}

struct Node
{
    int l, r;
    LL maxx, lazy;
}tree[maxn*4];

void pushdown(int root)
{
    if(tree[root].lazy != 0)
    {
        tree[root*2].maxx += tree[root].lazy;
        tree[root*2+1].maxx += tree[root].lazy;
        tree[root*2].lazy += tree[root].lazy;
        tree[root*2+1].lazy += tree[root].lazy;
        tree[root].maxx = max(tree[root*2].maxx, tree[root*2+1].maxx);
        tree[root].lazy = 0;
    }
}

void build(int root, int l, int r)
{
    tree[root].l = l;
    tree[root].r = r;
    tree[root].lazy = 0;
    if(l == r)
    {
        tree[root].maxx = dp[l];
        return ;
    }
    int mid = (l+r)/2;
    build(root*2, l, mid);
    build(root*2+1, mid+1, r);
    tree[root].maxx = max(tree[root*2].maxx, tree[root*2+1].maxx);
}

void update(int root, int l, int r, int val)
{
    if(tree[root].l>=l && tree[root].r<=r)
    {
        tree[root].lazy += val;
        tree[root].maxx += val;
        return;
    }
    pushdown(root);
    int mid = (tree[root].l+tree[root].r)/2;
    if(l <= mid)
    {
        update(root*2, l, r, val);
    }
    if(r > mid)
    {
        update(root*2+1, l, r, val);
    }
    tree[root].maxx = max(tree[root*2].maxx, tree[root*2+1].maxx);
}

LL query(int root, int l, int r)
{
    if(tree[root].l >= l && tree[root].r <= r)
    {
        return tree[root].maxx;
    }
    pushdown(root);
    int mid = (tree[root].l+tree[root].r)/2;
    LL res = -INF;
    if(l <= mid)
    {
        res = max(res, query(root*2, l, r));
    }
    if(r > mid)
    {
        res = max(res, query(root*2+1, l, r));
    }
    tree[root].maxx = max(tree[root*2].maxx, tree[root*2+1].maxx);
    return res;
}

int main()
{
    int T, n, m, cas = 0;
    scanf("%d", &T);
    while(T--)
    {
        init();
        scanf("%d %d", &n, &m);
        for(int i = 1; i < n; i++)
        {
            int a, b;
            scanf("%d %d", &a, &b);
            t[a].push_back(b);
            t[b].push_back(a);
        }
        for(int i = 0; i < n; i++)
        {
            scanf("%lld", &val[i]);
            cost[i] = val[i];
        }
        redfs(0);
        dfs(0, cnt);
        build(1, 1, cnt);
        printf("Case #%d:\n", ++cas);
        for(int i = 0; i < m; i++)
        {
            int q;
            scanf("%d", &q);
            if(q == 0)
            {
                int x;
                LL y;
                scanf("%d %lld", &x, &y);
                update(1, in[x], out[x], y-cost[x]);
                cost[x] = y;
            }
            else
            {
                int x;
                scanf("%d", &x);
                LL ans = query(1, in[x], out[x]);
                printf("%lld\n", ans);
            }
        }
    }
    return 0;
}