hdu2196Computer 树形DP

题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=2196

思路：

一看就是一道树形DP的题目，对于一个节点来说，到它的最远距离的路径可能来于子树，也可能来源于经过父亲节点的路径，所以我们两次DFS即可。

第一次DFS自底向上(从叶节点开始),依次求出每个节点的在其子树上的最大距离和次大距离

第二次DFS自顶向下(从根节点开始),通过比较经过父亲节点的路径的最大距离和来源于子树的最大距离比较然后更新最大距离

至于为什么要保存次大距离呢？？因为经过父亲节点的最大距离可能刚好经过当前的孩子节点，那么我们就只能通过当前孩子到父亲节点的距离加上经过父亲节点的路径次大值和当前节点的位于其子树的路径的最大距离的比较来更新最大距离咯。

虽然思路还是比较清晰的，自己实现起来还是比较难的。。。。

代码如下：

 #include<cstdlib>
 #include<cstring>
 #include<cstdio>
 #include<iostream>
 using namespace std;
 #define MAX 10010
 class node
 {
    public:
    int to;
    int w;
    int next;

 };
 node edge[*MAX];
 int head[MAX];
 int tol;
 int maxn[MAX];
 int smaxn[MAX];
 int m_id[MAX];
 int sm_id[MAX];
 int vis[MAX];
 void init()
 {
     memset(head,-,sizeof(head));
     memset(maxn,,sizeof(maxn));
     memset(smaxn,,sizeof(smaxn));
     memset(vis,,sizeof(vis));
     tol=;
 }
 void Build_Tree(int  u,int v,int w)
 {
     edge[tol].to=v;
     edge[tol].w=w;
     edge[tol].next=head[u];
     head[u]=tol++;
 }
 void dfs1(int root,int parent)
 {
         vis[root]=;
         for(int i=head[root];i!=-;i=edge[i].next)
         {
           if(vis[edge[i].to]) continue;
           int son=edge[i].to;
           dfs1(son,root);
           int len=edge[i].w;
           if(smaxn[root]<maxn[son]+len)
           {
               smaxn[root]=maxn[son]+len;
               sm_id[root]=son;
               if(smaxn[root]>maxn[root])
               {
                     swap(smaxn[root],maxn[root]);
                     swap(sm_id[root],m_id[root]);
               }
           }
         }
 }
 void dfs2(int root ,int  parent)
 {
     for(int i=head[root];i!=-;i=edge[i].next)
     {
          if(edge[i].to==parent) continue;
          int son=edge[i].to;
          if(m_id[root]==son)
          {
               if(edge[i].w+smaxn[root]>smaxn[son])
               {
                     smaxn[son]=edge[i].w+smaxn[root];
                     sm_id[son]=root;
                     if(smaxn[son]>maxn[son])
                     {
                          swap(smaxn[son],maxn[son]);
                          swap(sm_id[son],m_id[son]);
                     }
               }
          }
          else
         {
             if(edge[i].w+maxn[root]>smaxn[son])
             {
                 smaxn[son]=edge[i].w+maxn[root];
                 sm_id[son]=root;
                 if(smaxn[son]>maxn[son])
                 {
                     swap(smaxn[son],maxn[son]);
                     swap(m_id[son],sm_id[son]);
                 }
             }
         }
         dfs2(son,root);
     }

 }
 int n;
 int main()
 {
         while(scanf("%d",&n)!=EOF)
         {
             init();
            for(int i=;i<=n;i++)
            {
               int u,w;
               scanf("%d%d",&u,&w);
               Build_Tree(i,u,w);
               Build_Tree(u,i,w);
            }
            dfs1(,-);
            dfs2(,-);
            for(int i=;i<=n;i++)
              cout<<maxn[i]<<endl;

         }
         return ;
  }