HDU 5692 Snacks 【DFS序+线段树】

Snacks

Time Limit: 10000/5000 MS (Java/Others)    Memory Limit:65536/65536 K (Java/Others)
Total Submission(s): 3282    Accepted Submission(s): 762

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

【题意】

RT.

【思路】

分析题意 ，我们发现对于每次查询，其实相当于是从节点0到节点x及其某个子节点整条路径价值和的最大值。那么就会想到用DFS序来解决这个问题。

用一次DFS求出进入及走出每个节点的编号，在这两个编号之间的便是其子节点。我们先预处理，使每个编号的值对应于节点0到这个点整条路径的价值和，那么问题就转化成了求区间最值(【left[x],right[x]】)。修改就变成了区间值修改，用线段树实现即可。

#include <cstdio>
#include <vector>
#include <cstring>
#include <algorithm>
using namespace std;
#define mst(a,b) memset((a),(b),sizeof(a))
#define rush() int T;scanf("%d",&T);while(T--)
#define lson l,m,rt<<1
#define rson m+1,r,rt<<1|1

typedef long long ll;
const int maxn = 100005;
const ll mod = 1e9+7;
const ll INF = 1e15;
const double eps = 1e-9;

int n,m;
int cnt,tot;
ll val[maxn];
int left[maxn],right[maxn];
ll dis[maxn],a[maxn];
ll tree[maxn<<2];
ll flag[maxn<<2];
vector<int>vec[maxn];

void dfs(int u,int pre)
{
    cnt++;
    a[cnt]=dis[u];
    left[u]=cnt;
    for(int i=0; i<vec[u].size(); i++)
    {
        int v=vec[u][i];
        if(v==pre) continue;
        dis[v]=dis[u]+val[v];
        dfs(v,u);
    }
    right[u]=cnt;
}

void pushup(int rt)
{
    tree[rt]=max(tree[rt<<1],tree[rt<<1|1]);
}

void pushdown(int rt)
{
    if(flag[rt])
    {
        flag[rt<<1]+=flag[rt];
        flag[rt<<1|1]+=flag[rt];
        tree[rt<<1]+=flag[rt];
        tree[rt<<1|1]+=flag[rt];
        flag[rt]=0;
    }
}

void build(int l,int r,int rt)
{
    if(l==r)
    {
        tree[rt]=a[l];
        return;
    }
    int m=(l+r)/2;
    build(lson);
    build(rson);
    pushup(rt);
}

void update(int L,int R,ll num,int l,int r,int rt)
{
    if(L<=l&&r<=R)
    {
        tree[rt]+=num;
        flag[rt]+=num;
        return;
    }
    int m=(l+r)/2;
    pushdown(rt);
    if(L<=m)
    {
        update(L,R,num,lson);
    }
    if(m<R)
    {
        update(L,R,num,rson);
    }
    pushup(rt);
}

ll query(int L,int R,int l,int r,int rt)
{
    if(L>r||R<l) return -INF;
    if(L<=l&&r<=R)
    {
        return tree[rt];
    }
    pushdown(rt);
    int m=(l+r)/2;
    return max(query(L,R,lson),query(L,R,rson));
}

int main()
{
    int cas=1;
    int x,y,op;
    rush()
    {
        cnt=0;
        scanf("%d%d",&n,&m);
        for(int i=0; i<=n; i++)
        {
            vec[i].clear();
        }
        for(int i=1; i<n; i++)
        {
            scanf("%d%d",&x,&y);
            vec[x].push_back(y);
            vec[y].push_back(x);
        }
        for(int i=0; i<n; i++)
        {
            scanf("%I64d",&val[i]);
        }
        dis[0]=val[0];
        dfs(0,-1);
        build(1,n,1);
        mst(flag,0);
        printf("Case #%d:\n",cas++);
        for(int i=0; i<m; i++)
        {
            scanf("%d",&op);
            if(op)
            {
                scanf("%d",&x);
                printf("%I64d\n",query(left[x],right[x],1,n,1));
            }
            else
            {
                scanf("%d%d",&x,&y);
                update(left[x],right[x],(ll)y-val[x],1,n,1);
                val[x]=(ll)y;
            }
        }
    }
    return 0;
}