HDU 2196 Computer 树形dp

题目链接

Computer

Time Limit: 1000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 38500    Accepted Submission(s): 6998

 

Problem Description

A school bought the first computer some time ago(so this computer's id is 1). During the recent years the school bought N-1 new computers. Each new computer was connected to one of settled earlier. Managers of school are anxious about slow functioning of the net and want to know the maximum distance Si for which i-th computer needs to send signal (i.e. length of cable to the most distant computer). You need to provide this information.

Hint: the example input is corresponding to this graph. And from the graph, you can see that the computer 4 is farthest one from 1, so S1 = 3. Computer 4 and 5 are the farthest ones from 2, so S2 = 2. Computer 5 is the farthest one from 3, so S3 = 3. we also get S4 = 4, S5 = 4.

 

 

Input

Input file contains multiple test cases.In each case there is natural number N (N<=10000) in the first line, followed by (N-1) lines with descriptions of computers. i-th line contains two natural numbers - number of computer, to which i-th computer is connected and length of cable used for connection. Total length of cable does not exceed 10^9. Numbers in lines of input are separated by a space.

 

 

Output

For each case output N lines. i-th line must contain number Si for i-th computer (1<=i<=N).

 

 

Sample Input

5 1 1 2 1 3 1 1 1

 

 

Sample Output

3 2 3 4 4

 

给你一颗树，以及边的边权，求每个点最远的点。

如果是求一个点的最远的点，直接无向边建树dfs即可。但是本题这样复杂度O()肯定是不行的，只能转换思路。

我们发现所谓最远的点一定是这个点到那个点的一条链，我们称之为最远链，那么只有两种可能，最远链要么在子树，要么经过父亲节点。

在子树的最远链可以一遍dfs解决，但在dfs的时候，我们同时储存dp[u][0]最远链和dp[u][1]次远链，一会有用。

我们知道根节点没有父亲节点，用dp[u][2]存储走父亲节点的最大值，dp[1][2]=0。

v是u的儿子节点,w[i]是节点i接近根节点的那条边的边权。

考虑其他节点经过父亲节点的情况。那么又要分两种情况，

1、儿子在父亲最远链，dp[v][0]+w[v]==dp[u][0]，此时儿子走父亲有两种情况，一种是走父亲的次短链，另一种就是走“父亲的走父亲节点最远链”，就是走爷爷节点。dp[v][2]=max(dp[u][1],dp[u][2])+w[v].

2、儿子不在父亲的最远链，dp[v][0]+w[v]！=dp[u][0]，那么儿子要么走父亲最远链，要么走爷爷节点。dp[v][2]=max(dp[u][0],dp[u][2])+w[v].

最后每个点的结果就是max(dp[u][0],dp[u][2])。

 

#include <iostream>
#include <algorithm>
#include <cstring>
#define ms(a,b) memset(a,b,sizeof(a))
#include <vector>
using namespace std;
const int N=1e4+10;
vector<int>tr[N];
int w[N],dp[N][3];
void dfs1(int u)//子树，从下往上更新
{
	for(int i=0;i<tr[u].size();i++)
	{
		int v=tr[u][i];
		dfs1(v);
		if(dp[v][0]+w[v]>=dp[u][0])//更新子数最远点和次远点
		{
			dp[u][1]=dp[u][0];
			dp[u][0]=dp[v][0]+w[v];
		}
		else
		if(dp[v][0]+w[v]>dp[u][1])
			dp[u][1]=dp[v][0]+w[v];
	}
}
void dfs2(int u)//父亲节点，从顶往下更新
{
	for(int i=0;i<tr[u].size();i++)
	{
		int v=tr[u][i];
		if(dp[v][0]+w[v]==dp[u][0])//dp[u][0]==dp[u][1]//v在u的最长链
			dp[v][2]=max(dp[u][1],dp[u][2])+w[v];
		else//v不在u的最长链
			dp[v][2]=max(dp[u][0],dp[u][2])+w[v];
		dfs2(v);
	}
}
int main()
{
	ios::sync_with_stdio(false);
	cin.tie(0);
	int n,x;
	while(cin>>n)
	{
		ms(dp,0);
		for(int i=1;i<=n;i++)	
			tr[i].clear();
		for(int i=2;i<=n;i++)
		{
			cin>>x>>w[i];
			tr[x].push_back(i);
		}
		dfs1(1);
		dp[1][2]=0;//初始化根节点，不存在走父亲节点最远链
		dfs2(1);
		for(int i=1;i<=n;i++)	
			cout<<max(dp[i][0],dp[i][2])<<endl; //子树最远和走父亲节点最远取max
	}
}