【氪金带东】树的直径

题目

题意
实验室里原先有一台电脑(编号为1)，最近氪金带师咕咕东又为实验室购置了N-1台电脑，编号为2到N。每台电脑都用网线连接到一台先前安装的电脑上。但是咕咕东担心网速太慢，他希望知道第i台电脑到其他电脑的最大网线长度，但是可怜的咕咕东在不久前刚刚遭受了宇宙射线的降智打击，请你帮帮他。
提示: 样例输入对应这个图，从这个图中你可以看出，距离1号电脑最远的电脑是4号电脑，他们之间的距离是3。 4号电脑与5号电脑都是距离2号电脑最远的点，故其答案是2。5号电脑距离3号电脑最远，故对于3号电脑来说它的答案是3。同样的我们可以计算出4号电脑和5号电脑的答案是4.
Input
输入文件包含多组测试数据。对于每组测试数据，第一行一个整数N (N<=10000)，接下来有N-1行，每一行两个数，对于第i行的两个数，它们表示与i号电脑连接的电脑编号以及它们之间网线的长度。网线的总长度不会超过10^9，每个数之间用一个空格隔开。
Output
对于每组测试数据输出N行，第i行表示i号电脑的答案 (1<=i<=N).
Sample Input
5
1 1
2 1
3 1
1 1
Sample Output
3
2
3
4
4

题目大意

本题给出的是一棵带权树，要求得到树种每个节点所能到达的最远距离。题目输入若干组数据，数据会从 2 号点开始，给出与他连接的点的下标和路径长度，一直给到第 n 号点。

解题思路

读到本题可以发现要求最长路径长度，同时又是树形结构，所以自然而然想到树的直径方面的问题。树的直径长度指树中距离最远两点间的距离，求解方法需要对树进行两次遍历，第一次可以从任意点开始，找到他可以到达的最远节点，记录这一节点，随后第二次遍历便从这一记录的节点开始，找到他能到达的最远节点，由此这两个节点就对应了树的直径。
找到树的直径后便可以开始考虑树中每个节点所能到达的最远距离。经过思考可以发现每个节点到其他节点距离不会超过树的直径长，所以可以考虑该节点到直径两个节点距离，其中的较大值显然就是该节点能到达的最远距离。这时再次遍历树，找到对应结果即可。
除此之外，本题涉及到图的遍历问题。其中遍历的方法也就是之前学过的bfs和dfs，但对于图的不同表示方法，在细节上要多加注意。本次我使用的前向星法中就由于索索过程中对到两个端点路径长度的更新记录不细致，导致最终结果出现问题。

具体代码

#include<iostream>
#include<algorithm>
#include<stdio.h>
#include<math.h>
#include<queue>
#include<string.h>
#define MAXN 50010
using namespace std;

struct Edge
{
    int u,v,w,nxt;
}edge[MAXN];
int h[MAXN],tot,v1,v2,vis[MAXN],dis[MAXN];
int n;
int ans[2][MAXN];

void add(int u,int v,int w)
{
    edge[++tot].u=u;
    edge[tot].v=v;
    edge[tot].w=w;
    edge[tot].nxt=h[u];
    h[u]=tot;
}

void bfs(int u,int flag)
{
    memset(vis,0,sizeof(vis));
    memset(dis,0,sizeof(dis));
    int maxi = 0;
    queue<int> q;
    q.push(u);
    vis[u] = true;
    while(!q.empty())
    {
        int now = q.front();
		q.pop();
        for(int i = h[now]; i != -1; i = edge[i].nxt)
        {
            int to = edge[i].v;
            if(!vis[to])
            {
                dis[to] = dis[now] + edge[i].w;
                if(dis[to] > maxi)
                {
                    maxi = dis[to];
                    if(flag == 1)
                    {
                    	v1 = to;
					}
					else
					{
						v2 = to;
					}
                }
                vis[to] = 1;
                q.push(to);
            }
        }
    }
}

void bfss(int u, int flag)
{
    memset(vis,0,sizeof(vis));
    queue<int> q;
    q.push(u);
    vis[u] = true;
    while(!q.empty())
    {
        int now = q.front();
		q.pop();
        for(int i = h[now]; i != -1; i = edge[i].nxt)
        {
            int to = edge[i].v;
            if(!vis[to])
            {
                ans[flag][to] = ans[flag][now] + edge[i].w;     
                vis[to] = 1;
                q.push(to);
            }
        }
    }
}
int main()
{
    while(cin>>n)
	{ 
    	memset(ans,0,sizeof(ans));
    	tot = 0;
		v1 = 0;
		v2 = 0;
    	int u,v,w;
    	for(int i=1;i<=n;i++)
    	{
    		h[i]=-1;
		}
    	for(int i = 2; i <= n; i++)
    	{
    	    cin>>v>>w;
    	    add(i,v,w);
   	    	add(v,i,w);
    	}

    	bfs(1,1);
    	bfs(v1,2);
    
    	bfss(v1,0);
		bfss(v2,1);
    	for(int i=1;i<=n;i++)
    	{
    		cout << max(ans[0][i],ans[1][i]) << endl;
		}
	}
    return 0;
}