hdu 2196 computer

题意是求树中每个点到所有叶子节点的距离的最大值是多少。
由于对于一个节点来说，可能得到的距离最大的值的路径来自他的子树，或者从他的父节点过来，所以用两次DFS。
第一次DFS求出所有节点在他的子树范围内到叶子节点距离的最大值和第二大的值，第二次DFS更新从父节点过来的情况就可以了。

因为如果只存最大值的话，判断一个点的从父节点过来的最大值，那么如果他的父节点存的最大值正好是从该点过来的，那么就失去了从父节点过来的状态，所以要记录最大的两个值。

/***********************************************
 * Author: fisty
 * Created Time: 2015/2/21 14:11:03
 * File Name   : hdu.cpp
 *********************************************** */
#include <iostream>
#include <cstring>
#include <deque>
#include <cmath>
#include <queue>
#include <stack>
#include <list>
#include <map>
#include <set>
#include <string>
#include <vector>
#include <cstdio>
#include <bitset>
#include <algorithm>
using namespace std;
#define Debug(x) cout << #x << " " << x <<endl
#define Memset(x, a) memset(x, a, sizeof(x))
const int INF = 0x3f3f3f3f;
typedef long long LL;
typedef pair<int, int> P;
#define FOR(i, a, b) for(int i = a;i < b; i++)
#define MAX_N 20010
LL longest[MAX_N];  //最长路
LL longer[MAX_N];   //次长路
int idest[MAX_N];   //最大路
int ider[MAX_N];    //次短路
struct edge{
    int to;
    int cost;
    edge(int _to, int _cost):to(_to), cost(_cost){}
};
vector<edge> G[MAX_N];
void dfs1(int u, int fa){
    longest[u] = 0;
    longer[u] = 0;
    for(int i = 0;i < G[u].size(); i++){
        edge e = G[u][i];
        if(e.to == fa) continue;
        dfs1(e.to, u);
        if(longer[u] < longest[e.to] + e.cost){
            longer[u] = longest[e.to] + e.cost;
            ider[u] = e.to;
            if(longer[u] > longest[u]){
                swap(longer[u], longest[u]);
                swap(ider[u], idest[u]);
            }
        }
    }
}

void dfs2(int u, int fa){
    for(int i = 0;i < G[u].size(); i++){
        edge e = G[u][i];
        int v = e.to;
        if(v == fa) continue;
        if(v == idest[u]){
            if(longer[v] < longer[u] + e.cost){
                longer[v] = longer[u] + e.cost;
                ider[v] = u;
                if(longer[v] > longest[v]){
                    swap(longer[v], longest[v]);
                    swap(ider[v], idest[v]);
                }
            }
        }else{
            if(longer[v] < longest[u] + e.cost){
                longer[v] = longest[u] + e.cost;
                ider[v] = u;    
                if(longer[v] > longest[v]){
                    swap(longest[v], longer[v]);
                    swap(ider[v], idest[v]);
                }
            }
        }
        dfs2(v, u);
    }

}
int main() {
    //freopen("in.cpp", "r", stdin);
    cin.tie(0);
    ios::sync_with_stdio(false);
    int n;
    while(cin >> n){
        FOR(i, 0, n+1){
            G[i].clear();
        }
        Memset(longest, 0);
        Memset(longer, 0);
        int v, cost;
        FOR(i, 2, n+1){    
            cin >> v >> cost;
            G[i].push_back(edge(v, cost));
            G[v].push_back(edge(i, cost));
        }
        dfs1(1, -1);
        dfs2(1, -1);
        for(int i = 1;i <= n; i++){
            cout << longest[i] << endl;
        }
    }
    return 0;
}