网线长度
实验室里原先有一台电脑(编号为1)，最近又为实验室购置了N-1台电脑，编号为2到N。每台电脑都用网线连接到一台先前安装的电脑上。我们希望知道第i台电脑到其他电脑的最大网线长度。
提示: 样例输入对应这个图，从这个图中你可以看出，距离1号电脑最远的电脑是4号电脑，他们之间的距离是3。 4号电脑与5号电脑都是距离2号电脑最远的点，故其答案是2。5号电脑距离3号电脑最远，故对于3号电脑来说它的答案是3。同样的我们可以计算出4号电脑和5号电脑的答案是4.
输入文件包含多组测试数据。对于每组测试数据，第一行一个整数N (N<=10000)，接下来有N-1行，每一行两个数，对于第i行的两个数，它们表示与i号电脑连接的电脑编号以及它们之间网线的长度。网线的总长度不会超过10^9，每个数之间用一个空格隔开
对于每组测试数据输出N行，第i行表示i号电脑的答案 (1<=i<=N)
sample input:
5
1 1
2 1
3 1
1 1
sample output:
3
2
3
4
4
思路
- 题目说了这么多，其实就是构建一棵树，然后寻找离每个节点最远的结点
- 所以起初我使用树形DP的做法来解决这个问题，把无根树化为有根树来处理
- 比如对于上面这棵树，要求点4的最长距离，可以将树tree1分解成以节点4为根节点的tree2和以节点4的父节点为根节点的树tree1-tree2;这样的话，对于整棵树来说，tree2中距离节点2最远的距离记作l1,tree1-tree2中最远的距离记作l2,那么最终的答案就是max(l1,l2+1).
- 利用一个二维数组来记录。f[i][0]表示顶点为i的子树距离顶点i的最长距离；f[i][1]表示i的父节点的子树-i子树的最长距离+1（i与i的父节点距离）
- 所有的f[i][0]都做一次dfs求每一个节点到叶子节点的最长距离，然后从父节点递推到子节点计算所有的f[i][1]
- 这种经典树形DP的实现代码如下：
#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<algorithm>
using namespace std;
struct edge
{
int v,w,next;
}edge[10111];
int head[10111];
int n;
void add(int u,int v,int w)
{
edge[n].v=v;
edge[n].w=w;
edge[n].next=head[u];
head[u]=n++;
}
long long path[3][10011];
int visit[10011];
void dfs(int u,int far)
{
long long mx0=0,mx1=0;
for(int i=head[u];i!=-1;i=edge[i].next)
{
int v=edge[i].v;
if(v==far) continue;
dfs(v,u);
if(mx0<=path[0][v]+edge[i].w)
{
mx1=mx0;
mx0=path[0][v]+edge[i].w;
visit[u]=v;
}
else if(mx1<path[0][v]+edge[i].w) mx1=path[0][v]+edge[i].w;
else if(mx1<path[1][v]+edge[i].w) mx1=path[1][v]+edge[i].w;
}
path[0][u]=mx0;
path[1][u]=mx1;
}
void dfss(int u,int far)
{
for(int i=head[u];i!=-1;i=edge[i].next)
{
int v=edge[i].v;
if(v==far) continue;
if(visit[u]==v) path[2][v]=max(path[1][u]+edge[i].w,path[2][u]+edge[i].w);
else path[2][v]=max(path[0][u]+edge[i].w,path[2][u]+edge[i].w);
dfss(v,u);
}
}
int main()
{
int a,b,c;
while (~scanf("%d",&c))
{
n=0;
memset(head,-1,sizeof(head));
for(int i=2;i<=c;i++)
{
scanf("%d%d",&a,&b);
add(i,a,b);
add(a,i,b);
}
memset(path,0,sizeof(path));
dfs(1,1);
dfss(1,1);
for(int i=1;i<=c;i++)
cout<<max(path[0][i],path[2][i])<<endl;
}
return 0;
}- 但是这样写出现了TLE的问题，可能是测试数据卡的比较严，所以采用另一种思路，对于树中任意顶点进行一遍bfs,找到一个距离它最远的顶点作为端点1（肯定是一个叶子节点），然后再从端点进行bfs,找到距离最远的点，肯定是一个叶子节点，我们认为他是端点2
- 这样的话以这两个端点为起点对这棵树中所有的点都进行bfs,记录下距离最终的结果就是两个端点到这个点的距离的较大值
- 我们将树中最远的两个叶子节点之间的距离成为树的直径，这两个点被称为端点；整棵树中任意两个节点之间的距离都小于等于树的直径
#include<iostream>
#include<algorithm>
#include<queue>
#include<string.h>
using namespace std;
const int N=500001;
struct edge
{
int u,v;
int w;
int next;
}e[N];
int a[N],visit[N],dis[N];
int tot;
int p1,p2;
int ans[2][N];//0,1
void add(int u,int v,int w)
{
tot++;
e[tot].u=u;
e[tot].v=v;
e[tot].w=w;
e[tot].next=a[u];
a[u]=tot;
}
void bfs(int node,int flag)
{
memset(visit,0,sizeof(visit));
memset(dis,0,sizeof(dis));
int length=0;
queue<int> q;
q.push(node);
visit[node]=true;
while(!q.empty())
{
int temp=q.front();
q.pop();
for(int i=a[temp];i!=-1;i=e[i].next)
{
int nex=e[i].v;
if(!visit[nex])
{
dis[nex]=dis[temp]+e[i].w;
if(dis[nex]>length)
{
length=dis[nex];
if(flag==true)
p1=nex;
else p2=nex;
}
visit[nex]=1;
q.push(nex);
}
}
}
}
void bfss(int node,int flag)
{
memset(visit,0,sizeof(visit));
queue<int> q;
q.push(node);
visit[node]=true;
while(!q.empty())
{
int temp=q.front();
q.pop();
for(int i=a[temp];i!=-1;i=e[i].next)
{
int nex=e[i].v;
if(!visit[nex])
{
ans[flag][nex]=ans[flag][temp]+e[i].w;
visit[nex]=true;
q.push(nex);
}
}
}
}
int main()
{
int n;
while(scanf("%d",&n)!=EOF)
{
memset(ans,0,sizeof(ans));
tot=0;
p1=0;p2=0;
int u,v,w;
for(int i=1;i<=n;i++)
a[i]=-1;
for(int i=2;i<=n;i++)
{
scanf("%d%d",&v,&w);
add(i,v,w);
add(v,i,w);
}
bfs(1,1);
bfs(p1,2);
bfss(p1,0);
bfss(p2,1);
for(int i=1;i<=n;i++)
printf("%d\n",max(ans[0][i],ans[1][i]));
}
return 0;
}