周中训练笔记19——树形DP总结

       树形DP暂时告一段落，今天总结了一下：

      首先，树形DP=树+DP，是一种二维的DP题目，也可以结合背包问题，因为子树的数量不确定，所以一般用vector来存储子节点或子树个数。

     平时作的动态规划都是线性的或者是建立在图上的，线性的动态规划有二种方向既向前和向后，相应的线性的动态

规划有二种方法既顺推与逆推，而树型动态规划是建立在树上的，所以也相应的有二个方向： 

    1、叶－>根：在回溯的时候从叶子节点往上更新信息
    2、根 - >叶：往往是在从叶往根dfs一遍之后（相当于预处理），再重新往下获取最后的答案。

   先看一道简单的例题：

   

poj 2342 Anniversary party   先来个题入门一下~
题意：
某公司要举办一次晚会，但是为了使得晚会的气氛更加活跃，每个参加晚会的人都不希望在晚会中见到他的直接上司，现在已知每个人的活跃指数和上司关系（当然不可能存在环），求邀请哪些人（多少人）来能使得晚会的总活跃指数最大。

解题思路：
任何一个点的取舍可以看作一种决策，那么状态就是在某个点取的时候或者不取的时候，以他为根的子树能有的最大活跃总值。分别可以用f[i,1]和f[i,0]表示第i个人来和不来。
当i来的时候，dp[i][1] += dp[j][0];//j为i的下属
当i不来的时候，dp[i][0] +=max(dp[j][1],dp[j][0]);//j为i的下属

[cpp]  view plain  copy

1. #include<iostream>  
2. #include<cmath>  
3. #include<algorithm>  
4. #include<vector>  
5. #include<cstdio>  
6. #include<cstdlib>  
7. #include<cstring>  
8. #include<string>  
9.   
10. using namespace std;  
11.   
12. #define maxn 6005  
13.   
14. int n;  
15. int dp[maxn][2],father[maxn];//dp[i][0]0表示不去，dp[i][1]1表示去了  
16. bool visited[maxn];  
17.   
18. void tree_dp(int node)  
19. {  
20.     int i;  
21.     visited[node] = 1;  
22.     for(i=1; i<=n; i++)  
23.     {  
24.         if(!visited[i]&&father[i] == node)//i为下属  
25.         {  
26.             tree_dp(i);//递归调用孩子结点，从叶子结点开始dp  
27.             //关键  
28.             dp[node][1] += dp[i][0];//上司来,下属不来  
29.             dp[node][0] +=max(dp[i][1],dp[i][0]);//上司不来，下属来、不来  
30.         }  
31.     }  
32. }  
33.   
34. int main()  
35. {  
36.     int i;  
37.     int f,c,root;  
38.     while(scanf("%d",&n)!=EOF)  
39.     {  
40.         memset(dp,0,sizeof(dp));  
41.         memset(father,0,sizeof(father));  
42.         memset(visited,0,sizeof(visited));  
43.         for(i=1; i<=n; i++)  
44.         {  
45.             scanf("%d",&dp[i][1]);  
46.         }  
47.         root = 0;//记录父结点  
48.         bool beg = 1;  
49.         while (scanf("%d %d",&c,&f),c||f)  
50.         {  
51.             father[c] = f;  
52.             if( root == c || beg )  
53.             {  
54.                 root = f;  
55.             }  
56.         }  
57.         while(father[root])//查找父结点  
58.             root=father[root];  
59.         tree_dp(root);  
60.         int imax=max(dp[root][0],dp[root][1]);  
61.         printf("%d\n",imax);  
62.     }  
63.     return 0;  
64. }  

       这跟普通的DP一样，只不过扩展到了二维，只要找到状态转移方程，再用递归逐个算出每个子节点所对应的权值，就ok啦！

  接下来再看一道结合背包问题的树形DP：

   

hdu1561 树形DP The More The Better

Problem Description
ACboy很喜欢玩一种战略游戏，在一个地图上，有N座城堡，每座城堡都有一定的宝物，在每次游戏中ACboy允许攻克M个城堡并获得里面的宝物。但由于地理位置原因，有些城堡不能直接攻克，要攻克这些城堡必须先攻克其他某一个特定的城堡。你能帮ACboy算出要获得尽量多的宝物应该攻克哪M个城堡吗？
 
Input
每个测试实例首先包括2个整数，N,M.(1 <= M <= N <= 200);在接下来的N行里，每行包括2个整数，a,b. 在第 i 行，a 代表要攻克第 i 个城堡必须先攻克第 a 个城堡，如果 a = 0 则代表可以直接攻克第 i 个城堡。b 代表第 i 个城堡的宝物数量, b >= 0。当N = 0, M = 0输入结束。
 
Output
对于每个测试实例，输出一个整数，代表ACboy攻克M个城堡所获得的最多宝物的数量。
Sample Input
3 2
0 1
0 2
0 3
7 4
2 2
0 1
0 4
2 1
7 1
7 6
2 2
0 0
Sample Output
5
13
思路：自己建立一个根root，使森林的根都成为root的孩子，然后树形dfs+简单背包

0-1背包裸代码：
for i=1..N
    for v=V..0
        f[v]=max{f[v],f[v-c[i]]+w[i]};

状态转移方程：f[root][k]=max(f[root][k],f[root][k-j]+dp[u][j]);

m是个数，j是存几个，f[i][j]表示的是以i为根攻克j个城堡（且这j个城堡必须是它子树上的，不包括它本身），dp[i][j]表示的是是以i为根攻克j个城堡（且这j个城堡必须是它子树上的，一定它本身，ans[i]表示每个城堡的宝物，所以一定有dp[i][1]=ans[i];）。
for(int k=m;k>=0;k--)
      for(int j=0;j<=k;j++)
           f[root][k]=max(f[root][k],f[root][k-j]+dp[u][j]);

更新f[root][0~m]数组，然后全部更新完之后更新dp[root][0~m]。
如图所示样例，先从root即0点访问3，3没有孩子，执行更新dp操作 ，因为所以叶子都满足dp[i][0~m]=ans[i]，所以dp[3][0~m]都等于ans[3]，以下同理。

返回到root，更新f[0][m~0]。
访问root-->2-->7-->6，访问到叶子，更新dp[6][0~m]。返回7，更新f[7][m~0]，
从7-->5，更新叶子节点dp[5][0~m]，
从5-->7，再次更新f[7][m~0]，
从7-->2，更新dp[7][0~m]，返回2节点，更新f[2][m~0]，
从2-->4，更新叶子节点dp[4][0~m]，
从4-->2，更新f[2][m~0]，
从2-->1，更新dp[1][0~m]，
从1-->2，更新f[2][m~0]，
从2-->root,更新dp[2][0~m]，
更新f[0][m~0]，更新dp[0][0~m]。

[

1. #include<stdio.h>  
2. #include<string.h>  
3. #define N 205  
4. int n,m,edgeNum=0;  
5. int ans[N],dp[N][N],f[N][N];  
6. int visit[N],head[N];  
7. struct Line{int v,next;}edge[N];  
8. int max(int a,int b){return a>b?a:b;}  
9. void add(int u,int v)  
10. {  
11.     edge[edgeNum].v=v;  
12.     edge[edgeNum].next=head[u];  
13.     head[u]=edgeNum++;  
14. }  
15. void dfs(int root)  
16. {  
17.     visit[root]=1;  
18.     for(int i=head[root];i!=-1;i=edge[i].next)  
19.     {  
20.         int u=edge[i].v;  
21.         if(!visit[u])  
22.         {  
23.             dfs(u);  
24.             for(int k=m;k>=0;k--)  
25.               for(int j=0;j<=k;j++)  
26.               f[root][k]=max(f[root][k],f[root][k-j]+dp[u][j]);  
27.         }  
28.     }  
29.     for(int i=1;i<=m+1;i++)  
30.       dp[root][i]=f[root][i-1]+ans[root];  
31. }  
32. int main()  
33. {  
34.     int a,b;  
35.     while(scanf("%d%d",&n,&m)!=EOF)  
36.     {  
37.         if(n==0&&m==0) break;  
38.         edgeNum=ans[0]=0;  
39.         memset(f,0,sizeof(f));  
40.         memset(dp,0,sizeof(dp));  
41.         memset(head,-1,sizeof(head));  
42.         memset(visit,0,sizeof(visit));  
43.         for(int i=1;i<=n;i++)  
44.         {  
45.             scanf("%d%d",&a,&b);  
46.             ans[i]=b;  
47.             add(a,i);  
48.         }  
49.         dfs(0);  
50.         printf("%d\n",dp[0][m+1]);  
51.     }  
52. }  

        以上只是入门题目，能较简单的反映树形DP的基本思想，更复杂的题目说实话能看懂题解就不错了，现在根本做不出来。。。

      还需努力！