hdu2196

题意：

给出一棵树，求离每个节点最远的点的距离

思路：

把无根树转化成有根树分析，

对于上面那棵树，要求距结点2的最长距离，那么，就需要知道以2为顶点的子树（蓝色圈起的部分，我们叫它Tree（2）），距顶点2的最远距离L1

还有知道2的父节点1为根节点的树Tree（1）-Tree(2)部分（即红色圈起部分），距离结点1的最长距离+dist(1,2) = L2，那么最终距离结点2最远的距离就是max{L1，L2}

f[i][0],表示顶点为i的子树的，距顶点i的最长距离
f[i][1],表示Tree(i的父节点)-Tree(i)的最长距离+i跟i的父节点距离

要求所有的f[i][0]很简单，只要先做一次dfs求每个结点到叶子结点的最长距离即可。
然后要求f[i][1], 可以从父节点递推到子节点，

假设节点u有n个子节点，分别是v1,v2...vn
那么
如果vi不是u最长距离经过的节点，f[vi][1] = dist(vi,u)+max(f[u][0], f[u][1])
如果vi是u最长距离经过的节点，那么不能选择f[u][0],因为这保存的就是最长距离，要选择Tree（u）第二大距离secondDist,
可得f[vi][1] = dist(vi, u) + max(secondDist, f[u][1])

代码：

[cpp] view plaincopy

1. #include<iostream>  
2. #include<cstdio>  
3. #include<algorithm>  
4. #include<vector>  
5. #include<queue>  
6. #include<cmath>  
7. #include<cstring>  
8. using namespace std;  
9.   
10. typedef long long int64;  
11. const int INF = 0x3f3f3f3f;  
12. const double PI  = acos(-1.0);  
13.   
14. const int MAXN = 10010;  
15.   
16. struct Node{  
17.     int v, w;  
18. };  
19.   
20. vector<Node>adj[MAXN];  
21.   
22. int indeg[MAXN];  
23. int val[MAXN];  
24. int n, m;  
25. int64 f[MAXN][2];  
26. int vis[MAXN];  
27.   
28. int64 dfs1(int u){  
29.     vis[u] = true;  
30.     f[u][0] = 0;  
31.     for(int i=0; i<adj[u].size(); ++i){  
32.         int v = adj[u][i].v;  
33.         int w = adj[u][i].w;  
34.         if(vis[v]) continue;  
35.         f[u][0] = max(f[u][0], dfs1(v)+w);  
36.     }  
37.     return f[u][0];  
38. }  
39.   
40.   
41. void dfs2(int u, int fa_w){  
42.     vis[u] = true;  
43.   
44.     int max1=0, v1, max2=0, v2;  
45.   
46.     for(int i=0; i<adj[u].size(); ++i){  
47.         int v = adj[u][i].v;  
48.         int w = adj[u][i].w;  
49.         if(vis[v]) continue;  
50.         int tmp = f[v][0] + w;  
51.         if(tmp > max1){  
52.             max2 = max1; v2 = v1;  
53.             max1 = tmp; v1 = v;  
54.         }else if(tmp == max1 || tmp>max2){  
55.             max2 = tmp;  
56.             v2 = v;  
57.         }  
58.     }  
59.   
60.     if(u != 1){   
61.         int tmp = f[u][1];  
62.         int v = -1;  
63.         if(tmp > max1){  
64.             max2 = max1; v2 = v1;  
65.             max1 = tmp; v1 = v;  
66.         }else if(tmp == max1 || tmp>max2){  
67.             max2 = tmp;  
68.             v2 = v;  
69.         }  
70.     }  
71.   
72.     for(int i=0; i<adj[u].size(); ++i){  
73.         int v = adj[u][i].v;  
74.         int w = adj[u][i].w;  
75.         if(vis[v]) continue;  
76.         if(v==v1){  
77.             f[v][1] = max2 + w;  
78.         }else{  
79.             f[v][1] = max1 + w;   
80.         }  
81.         dfs2(v, w);  
82.     }  
83. }  
84.   
85. int main(){  
86.   
87.     while(~scanf("%d", &n) && n){  
88.   
89.         for(int i=1; i<=n; ++i) adj[i].clear();  
90.   
91.         for(int u=2; u<=n; ++u){  
92.             int v, w;  
93.             scanf("%d%d", &v, &w);  
94.             adj[u].push_back((Node){v, w});  
95.             adj[v].push_back((Node){u, w});  
96.         }  
97.           
98.         memset(f, 0, sizeof(f));  
99.   
100.         memset(vis, 0, sizeof(vis));  
101.         dfs1(1);  
102.   
103.         memset(vis, 0, sizeof(vis));  
104.         dfs2(1, 0);  
105.   
106.         for(int i=1; i<=n; ++i){  
107.             cout << max(f[i][0], f[i][1]) << endl;  
108.         }  
109.     }  
110.   
111.     return 0;  
112. }