hdu2196：Computer

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

题目大意
给你一棵n个结点的树，以及各边上的权值，求每一个结点能到达的最远距离。

解题思路
据说是一道经典的dp问题，要同时用到从根到叶和从叶到根两个方向的dp。
对于 (u,v)（有向）:
dp[u][0]表示在u的子树下u的最远距离是多少
dp[u][1]表示在u的子树下（和dp[u][0]不是同一孩子）u的次远距离是多少
dp[u][2]表示通过u的父亲能走的最远距离是多少
第一次从叶到根，对于(u,v)（有向），状态转移为 dp[u][0] = dp[v][0]+w[i]；所以要先算出dp[v][0]才能知道dp[u][0]。故是从下往上。

第二次从根往叶，其实就是再遍历一边图，把dp[v][2]算出来，显然：
dp[v][2] = max(dp[u][2]，dp[v][0]+w[i]==dp[u][0]?dp[u][1]:dp[u][0]) + w[i]；因为对结点v来说，最远距离只可能由两种状态转移过来，一是通过父节点u的最远距离，注意这个最短距离一定是经过u的父节点的；所以另一个状态即为通过u但不通过u的父结点的状态，而这一个状态一定是连接u与v的兄弟节点的，所以如果dp[u][0]是包含v的，那么就必须要选择第二长的距离。
要算dp[v][2]，要先算dp[u][0]，所以从上往下。

最后的答案就是 max（dp[u][0]，dp[u][2]）

代码

#include<iostream>
#include<algorithm>
#include<memory.h>
using namespace std;
struct Edge
{
    int v,w,next;
};
Edge edge[20005];
int head[10005],tot;
int dp[10005][3];
void addedge(int u,int v,int w)
{
    edge[tot].v=v;
    edge[tot].w=w;
    edge[tot].next=head[u];
    head[u]=tot++;
}
void dfs1(int u,int v)//叶到根
{
    for(int i=head[u];i!=-1;i=edge[i].next)
    {
        int v=edge[i].v;
        dfs1(v,u);
        int w=edge[i].w;
        int temp=dp[v][0]+w;
        if(temp>=dp[u][0])
        {
            dp[u][1]=dp[u][0];
            dp[u][0]=temp;
        }
        else if(temp>dp[u][1])
        dp[u][1]=temp;
    }
}
void dfs2(int u,int v)//根到叶
{
    for(int i=head[u];i!=-1;i=edge[i].next)
    {
        int v=edge[i].v;
        if(dp[u][0]==dp[v][0]+edge[i].w)
        dp[v][2]=max(dp[u][2],dp[u][1])+edge[i].w;
        else
        dp[v][2]=max(dp[u][2],dp[u][0])+edge[i].w;
        dfs2(v,u);
    }
}
int main()
{
    int n;
    while(cin>>n)
    {
        memset(head,-1,sizeof(head));
        tot=0;
        for(int v=2;v<=n;v++)
        {
            int u,w;
            cin>>u>>w;
            addedge(u,v,w);
        }
        memset(dp,0,sizeof(dp));
        dfs1(1,-1);
        dfs2(1,-1);
        for(int i=1;i<=n;i++)
        cout<<max(dp[i][0],dp[i][2])<<endl;
    }
    return 0;
}