hdu 5692 (节点深度为h 所有子节点

传送门

Snacks

Time Limit: 10000/5000 MS (Java/Others)    Memory Limit: 65536/65536 K (Java/Others)

Total Submission(s): 2989    Accepted Submission(s): 697


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<
18c1f
/span>的零食机与编号为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

 

Source

2016"百度之星" - 初赛（Astar
Round2A）

 

Recommend

wange2014

#pragma comment(linker, "/STACK:1024000000,1024000000")
#include <cstdio>
#include <cstring>
#include <algorithm>
#define ll long long
#define lson l, mid, rt << 1
#define rson mid + 1, r, rt << 1 | 1
using namespace std;
ll const INF = 1e18;
int const MAX = 100005;
int n, m;
ll a[MAX], sum[MAX << 2], lazy[MAX << 2], dis[MAX];
int l[MAX], r[MAX], nd[MAX], num;
int head[MAX], cnt;

struct EDGE
{
int to, nxt, val;//val 为值
}e[MAX << 1];

void Init()
{
num = 0;
cnt = 0;
memset(head, -1, sizeof(head));
}

void Add(int u, int v)
{
e[cnt].to = v;
e[cnt].nxt = head[u];
head[u] = cnt ++;
}
/*给定一棵n个节点的树，m次查询，每次查询需要求出某个节点深度为h的所有子节点。*/
void DFS(int u, int fa)//dfs序
{
num ++;
l[u] = num;
nd[num] = u;
for(int i = head[u]; i != -1; i = e[i].nxt)
{
int v = e[i].to;
if(v != fa)
{
dis[v] = dis[u] + a[v];
DFS(v, u);
}
}
r[u] = num;
}

void PushUp(int rt)
{
sum[rt] = max(sum[rt << 1], sum[rt << 1 | 1]);
return;
}

void PushDown(int rt)
{
if(lazy[rt])
{
sum[rt << 1] += lazy[rt];
sum[rt << 1 | 1] += lazy[rt];
lazy[rt << 1] += lazy[rt];
lazy[rt << 1 | 1] += lazy[rt];
lazy[rt] = 0;
}
return;
}

void Build(int l, int r, int rt)
{
lazy[rt] = 0;
if(l == r)
{
sum[rt] = dis[nd[l]];
return;
}
int mid = (l + r) >> 1;
Build(lson);
Build(rson);
PushUp(rt);
}

void Update(int L, int R, int val, int l, int r, int rt)
{
if(L <= l && r <= R)
{
lazy[rt] += val;
sum[rt] += val;
return;
}
int mid = (l + r) >> 1;
PushDown(rt);
if(L <= mid)
Update(L, R, val, lson);
if(mid < R)
Update(L, R, val, rson);
PushUp(rt);
}

ll Query(int L, int R, int l ,int r, int rt)
{
if(L <= l && r <= R)
return sum[rt];
int mid = (l + r) >> 1;
PushDown(rt);
ll ans = -INF;
if(L <= mid)
ans = max(ans, Query(L, R, lson));
if(mid < R)
ans = max(ans, Query(L, R, rson));
return ans;
}

int main()
{
int T;
scanf("%d", &T);
for(int ca = 1; ca <= T; ca++)
{
printf("Case #%d:\n", ca);
Init();
int x, y;
scanf("%d %d", &n, &m);
for(int i = 0; i < n - 1; i++)
{
scanf("%d %d", &x, &y);
Add(x, y);
Add(y, x);
}
for(int i = 0; i < n; i++)
scanf("%I64d", &a[i]);
dis[0] = a[0];
DFS(0, -1);
Build(1, n, 1);
while(m --)
{
int tp, x, y;
scanf("%d", &tp);
if(tp == 1)
{
scanf("%d", &x);
printf("%I64d\n", Query(l[x], r[x], 1, n, 1));
}
else
{
scanf("%d %d", &x, &y);
Update(l[x], r[x], y - a[x], 1, n, 1);
a[x] = y;
}
}
}
}

codeforce Propagating tree

void dfs(int u,int fa)
{
// sq[++pos]=u;
in[u]=++t;
for(int i=0; i<G[u].size(); i++)
{
int v=G[u][i];
if(v!=fa)
{
niv[v]=!niv[u];
dfs(v,u);
}
}
out[u]=t;
}