HDU 5834 Magic boy Bi Luo with his excited tree（树形dp）

http://acm.hdu.edu.cn/showproblem.php?pid=5834

题意：

一棵树上每个节点有一个价值$Vi$，每个节点只能获得一次，每走一次一条边要花费$Ci$，问从各个节点出发最多能收获多少价值。

思路：

需要考虑子节点和父亲节点两个方面。既然是这样，那就需要两次dfs来解决问题了，$dp[u][0]$表示从u出发最后还是回到u的最大价值和，$dp[u][1]$表示从u出发最后不回到u的最大价值和。

第一次dfs很显然就是计算出每个节点往其子树方向的$dp[u][0]$和$dp[u][1]$值。

第二次dfs就是再去考虑每个节点加上其父节点的情况，这里就需要维护一个最大值和一个次大值了，为什么呢？因为父节点的最大值可能最后停在了v子树，那么v子树到时候再去考虑父节点的时候就不对了，所以此时要将它改成次大值，这样它的最大值最后不会停在v子树。

总而言之，这是一道很经典的树形dp，不过没写出来。。

 #include<iostream>
 #include<algorithm>
 #include<cstring>
 #include<cstdio>
 #include<vector>
 #include<stack>
 #include<queue>
 #include<cmath>
 #include<map>
 #include<set>
 using namespace std;
 typedef long long ll;
 typedef pair<int,int> pll;
 const int INF = 0x3f3f3f3f;
 const int maxn=1e5+;

 int n;
 int val[maxn];
 int dp[maxn][];
 vector<pll> G[maxn];

 void dfs1(int u, int fa)  //求出每个顶点往子树方向的最大值,dp[u][0]表示最终回到u，dp[u][1]表示最终不回到u
 {
     dp[u][]=dp[u][]=val[u];
     for(int i=;i<G[u].size();i++)
     {
         int v=G[u][i].first;
         int w=G[u][i].second;
         if(v==fa)  continue;
         dfs1(v,u);
         if(dp[v][]-*w>)  dp[u][]+=dp[v][]-*w;
     }
     for(int i=;i<G[u].size();i++)
     {
         int v=G[u][i].first;
         int w=G[u][i].second;
         if(v==fa)  continue;
         int tmp = dp[u][]-max(,dp[v][]-*w)+(dp[v][]-w);
         if(dp[u][]<tmp)  dp[u][]=tmp;
     }
 }

 void dfs2(int u, int fa, int cost)  //处理往父亲节点的方向
 {
     int dir_tree=u;
     if(fa!=-)  if(dp[fa][]-*cost>)  dp[u][]+=dp[fa][]-*cost;
     int sub_large=dp[u][]=dp[u][];
     for(int i=;i<G[u].size();i++)
     {
         int v=G[u][i].first;
         int w=G[u][i].second;
         int tmp=dp[u][]-max(,dp[v][]-*w)+(dp[v][]-w);
         if(tmp>=dp[u][])  //计算最大权值和次大权值
         {
             sub_large=dp[u][];
             dp[u][]=tmp;
             dir_tree=v;
         }
         else if(tmp>=sub_large)   sub_large=tmp;
     }
     int pre0=dp[u][],pre1=dp[u][];  //出去该父节点对其子节点的影响
     for(int i=;i<G[u].size();i++)
     {
         int v=G[u][i].first;
         int w=G[u][i].second;
         if(v==fa)  continue;
         int tmp=dp[v][]-*w;
         if(tmp>)  dp[u][]-=tmp;  //子节点v往父节点走时，肯定不会再算v节点的子树
         if(dir_tree==v)  dp[u][]=sub_large; //如果u的最大值最后停留在v子树，则改成次大值
         if(tmp>)  dp[u][]-=tmp;  //和上面的第2句相同
         dfs2(v,u,w);
         dp[u][]=pre0,dp[u][]=pre1;
     }

 }

 int main()
 {
     //freopen("in.txt","r",stdin);
     int T;
     int kase=;
     scanf("%d",&T);
     while(T--)
     {
         scanf("%d",&n);
         for(int i=;i<=n;i++)  {G[i].clear();scanf("%d",&val[i]);}
         for(int i=;i<n;i++)
         {
             int u,v,w;
             scanf("%d%d%d",&u,&v,&w);
             G[u].push_back(make_pair(v,w));
             G[v].push_back(make_pair(u,w));
         }
         printf("Case #%d:\n",++kase);
         dfs1(,-);
         dfs2(,-,);
         for(int i=;i<=n;i++)  printf("%d\n",dp[i][]);
     }
     return ;
 }