hdu 2196 Computer(树的直径\树上dp)

题目链接

Computer

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

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
  
  

 

Author

scnu

 

题目大意：在一棵树上，有n个节点，边带有权，输出每个节点上以这个节点作点起点的最长距离。

题解：看了许多的题解，关于这个题有两种做法，一种是树上dp，另一种是找树的直径。

先说说第一种做法：

这里用了两次的bfs。
第一次是自上而下地求出每个节点的的最长距离f[ i ]，同时，求出在第二次bfs 要用的次长度g[ i ]。
自己画图可以知道，一个点的最长距离只可能是由它的子节点得到，或者从它的父结点的最长距离或者次长距离加上它与父节点的距离得到。从这里我们就可以得到状态转移方程。而且最后节点的最长距离就是f[ i ],h[ i ] 中的最大值。

第二种方法：

首先任意一次dfs求出树上最长直径的一个端点End,然后以该端点为起点再次dfs求出另一个端点，然后再次以求出的另一个端点为起点dfs,每次做dfs的时候都更新dist[]（dist[u]表示u到树上任意节点的最远距离），可以证明树上任意某个节点到树上任意节点的最远距离的端点一定会是树上直径的两个端点之一。

第一种做法代码：

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<vector>
#include<cstring>
using namespace std;
const int maxn=10000+10;
vector<pair<int,int> > G[maxn];
int f[maxn],g[maxn],h[maxn],path[maxn];
void init()
{
	for(int i=0;i<maxn;i++) G[i].clear();
	memset(f,0,sizeof(f));
	memset(g,0,sizeof(g));
	memset(h,0,sizeof(h));
	memset(path,0,sizeof(path));
}
int dfs(int u,int fa)
{
	for(int i=0;i<G[u].size();i++)
	{
		int v=G[u][i].first,w=G[u][i].second;
		if(v==fa) continue;
		dfs(v,u);
		if(f[v]+w>f[u]) {g[u]=f[u],f[u]=f[v]+w,path[u]=v;}
		else if(f[v]+w>g[u]) g[u]=f[v]+w;
	}
	return f[u];
}

void dfs1(int u,int fa)
{
	for(int i=0;i<G[u].size();i++)
	{
		int v=G[u][i].first,w=G[u][i].second;
		if(v==fa) continue;
		if(v==path[u]) h[v]=max(h[u],g[u])+w;
		else h[v]=max(h[u],f[u])+w;
		dfs1(v,u);
	}
}

int main()
{
	int n;
	while(~scanf("%d",&n))
	{
		init();
		for(int i=2;i<=n;i++)
		{
			int u,v;
			scanf("%d%d",&u,&v);
			G[i].push_back(make_pair(u,v));
			G[u].push_back(make_pair(i,v));
		}
		dfs(1,-1);
		dfs1(1,-1);
		for(int i=1;i<=n;i++)
		printf("%d\n",max(h[i],f[i]));
	}
}

第二种做法代码：

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<vector>
using namespace std;
const int maxn=10000+10;
int d[maxn],d1[maxn];
vector<pair<int,int> >G[maxn];
void dfs(int u,int fa,int w,int d[])
{
	d[u]=w;
	for(int i=0;i<G[u].size();i++)
	{
		int v=G[u][i].first;
		if(v==fa) continue;
		dfs(v,u,w+G[u][i].second,d);
	}
}
void init()
{
	for(int i=0;i<maxn;i++) G[i].clear();
}

int main()
{
	int n;
	while(~scanf("%d",&n))
	{
		init();
		for(int i=2;i<=n;i++)
		{
			int v,w;
			scanf("%d%d",&v,&w);
			G[i].push_back(make_pair(v,w));
			G[v].push_back(make_pair(i,w));
		}
		memset(d,0,sizeof(d));
		dfs(1,-1,0,d);
		int root=0,_max=0;
		for(int i=1;i<=n;i++)
		{
			if(d[i]>_max) 
			{
				_max=d[i];
				root=i;
			}
		}
		memset(d,0,sizeof(d));
		dfs(root,-1,0,d);
		root=0,_max=0;
		for(int i=1;i<=n;i++)
		{
			if(d[i]>_max)
			{
				_max=d[i];
				root=i;
			}
		}
		dfs(root,-1,0,d1);
		for(int i=1;i<=n;i++)
		printf("%d\n",max(d[i],d1[i]));
	}
}