hdu 2196 树形dp

题意:很简单，就是给你一棵树，每条边都有一定的权值，然后让你找到每个点所能走到的最远距离

链接:点我

那么我们可以这样高效的来处理

先以 1 作为根节点进行一次 dfs 遍历，遍历的时候把以 第 i 为根节点往子树方向可以走到的最远距离和次远距离给求出来，且这两个距离是不在同一个分支中的

然后我们进行第二次的从根节点开始dfs遍历，这时候我们要判断的是对于一个节点 i ，除了子树方向上可能有最远距离外，我通过父节点方向是否可以有更加远的距离

，而对于这个操作，我们只要访问父节点所能到达的最远距离，然后接上一段就行了，但是这里会产生一个问题——就是父节点的最远距离可能是会经过当前这个节点

的，因此我们要进行判断当前节点是否在父节点的最远距离的分支上

如果在的话，那么我们要换一个分支，且要是最远的，这个其实就是第一次dfs中求出的与最远路径不在同一分支上的次远路径，我们接上这段进行转移

如果不在的话，那么我们直接接上父节点的最远路径进行转移就行了

Sample Input

5

1 1 　　//2到1的距离为1

2 1 　　//3到2的距离为1

3 1

1 1

 

Sample Output

3 2 3 4 4

 

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
#include<cmath>
#include<queue>
#include<map>
using namespace std;
#define MOD 1000000007
const int INF=0x3f3f3f3f;
const double eps=1e-5;
typedef long long ll;
#define cl(a) memset(a,0,sizeof(a))
#define ts printf("*****
");
const int MAXN=10015;
int n,m,tt;
int tot,head[MAXN];
int maxn[MAXN];//该节点往下到叶子的最大距离
int smaxn[MAXN];//次大距离
int maxid[MAXN];//最大距离对应的序号
int smaxid[MAXN];//次大的序号
struct Edge
{
    int to,next,w;
}edge[MAXN*2];
void addedge(int u,int v,int w)
{
    edge[tot].to=v;
    edge[tot].w=w;
    edge[tot].next=head[u];
    head[u]=tot++;
}
void init()
{
    memset(head,-1,sizeof(head));
    cl(maxn);
    cl(smaxn);
    tot=0;
}
void dfs1(int u,int pre)
{
    for(int i=head[u];i!=-1;i=edge[i].next)
    {
        int v=edge[i].to;
        if(v==pre)  continue;
        dfs1(v,u);
        if(smaxn[u]<maxn[v]+edge[i].w)
        {
            smaxn[u]=maxn[v]+edge[i].w;
            smaxid[u]=v;
            if(smaxn[u]>maxn[u])
            {
                swap(smaxn[u],maxn[u]);
                swap(smaxid[u],maxid[u]);
            }
        }
    }
}
void dfs2(int u,int pre)
{
    for(int i=head[u];i!=-1;i=edge[i].next)
    {
        int v=edge[i].to;
        if(v==pre)  continue;
        if(v==maxid[u])    //父节点的最长路径经过v，v不能经过u再经过v，所以要找次长路径
        {
            if(smaxn[v]<smaxn[u]+edge[i].w)
            {
                smaxn[v]=edge[i].w+smaxn[u];
                smaxid[v]=u;
                if(smaxn[v]>maxn[v])
                {
                    swap(smaxn[v],maxn[v]);
                    swap(smaxid[v],maxid[v]);
                }
            }
        }
        else
        {
            if(smaxn[v]<maxn[u]+edge[i].w)
            {
                smaxn[v]=edge[i].w+maxn[u];
                smaxid[v]=u;
                if(smaxn[v]>maxn[v])
                {
                    swap(smaxn[v],maxn[v]);
                    swap(smaxid[v],maxid[v]);
                }
            }
        }
        dfs2(v,u);
    }
}
int main()
{
    int i,j,k;
    #ifndef ONLINE_JUDGE
    freopen("1.in","r",stdin);
    #endif
    while(scanf("%d",&n)!=EOF)
    {
        init();
        int u,w;
        for(i=2;i<=n;i++)
        {
            scanf("%d%d",&u,&w);
            addedge(i,u,w);
            addedge(u,i,w);
        }
        dfs1(1,-1);
        dfs2(1,-1);
        for(i=1;i<=n;i++)
        {
            printf("%d
",maxn[i]);
        }
    }
}