浅谈树形dp

总结：

这一周重点训练了树形dp。 对树形dp也有了一定的认识。
先说一下总的观点吧。 树形dp一般无非就是求出子节点的状态从而进一步去更新根节点的状态。 一般的话，会用到dfs，从根节点开始，依次向下深搜。 将所有的叶子节点的状态值求出来就去更新根节点。 这是从叶子节点向根节点依次传值。 也有从根节点向叶子节点传值的题目。 这种题目，一般只要深搜一遍就可以得到正确的答案了。

还有一种题目，就是在树上做背包。题目会给你一个限制条件（例如：在这颗树上，只能选M个节点，问怎么选能使选的价值总和最大）。想这种题目就是一个树上背包问题。 对于这种题目的话，我觉得用左孩子，右兄弟的办法去做，是最容易理解的。 但是左孩子，右兄弟来解决的话，就要求知道输入数据的孩子和父亲的关系。然后如果不用左孩子右兄弟的做法的话。 那么我们可以这样理解（以01背包为例）：对于一颗子树而言，当我们要求他的根节点的值时，我们一定是知道他的叶子节点的状态值才能求。所以，我们可以把他的叶子节点的状态值理解为一个物品。这样的话，和01背包就没有什么差别了。
对于树形dp的状态方程一般都是:
dp[i ][ ] = max{dp[v][ ] }
表示第i颗子树的状态值是由他的子节点的子树的状态值通过转换得来的。第二维看情况。

当然，还有许多其他种类，在此就不一一列举。

题目链接：http://poj.org/problem?id=2486
这个题目要求最多走k步，问能摘到最多多少苹果。
这是一个很典型的树上背包问题了。
树上背包问题的话，无非就是一点在树上做背包。
不过这个题，还有一个很有意思的地方，就是他一定回到起点吗？
题目没做要求，所以他可以回到起点，也可以不回到起点。
那么这就是两种情况了。 很明显，对于每颗子树都是有回到根节点和不回到根节点两种情况。

那么，状态转移方程就是：
dp[i][k][0]=max(dp[i][k][0],dp[v][t-2][0]+dp[i][k-t][0];
dp[i][k][1]=max(dp[i][k][1],dp[v][t-1][1]+dp[i][k-t][0],dp[v][t-2][0]+dp[i][k-t][1];
这两种情况了。
第一种表示在第i颗子树能走k步并回到根节点的情况。
他在第i颗子树上最多走k步，那我们就要看他给每个叶节点分配1到k步所产生的影响，并取最优解。（如果他给这个叶节点分配了t（1<=t<=k）步，那么其他所有的叶子就只能走k-t步了,然后需要看他给这个叶子节点分配了t步，对整棵树产生了什么影响。继而枚举每个叶节点分配了t步对整棵树的影响，并取得最优解）。
dp[v][t-2][0]表示：他给v这个叶子节点分配了t步并要回到根节点。
这里有个问题就是为什么要t-2。我们可以想，他从i节点到v节点要花费一步，这一步不能算到v子树里面去，要减去。同样，他要回到i节点，又要花费一步，要减去。

第二个表示在第i颗子树下走k步不回到根节点的情况。
他不回到根节点，那么我们要考虑他是在哪一个节点不回到根节点。
,dp[v][t-1][1]+dp[i][k-t][0] 表示 他是在v这个叶节点不回到根节点。
dp[v][t-2][0]+dp[i][k-t][1]表示，他是在不是v这个叶节点的其他叶节点不回到根节点。

代码：

#include"stdio.h"
#include"string.h"
#include"vector"
#include"algorithm"
using namespace std;

int N,M;
int weight[110],dp[110][220][2];
vector<int>Q[110];
void dfs(int root,int pre)
{
    for(int i = 0; i < Q[root].size(); i ++)
    {
        int son = Q[root][i];
        if(son == pre)
            continue;
        dfs(son,root);//一直递归，直到叶子节点。
        for(int k = M; k >= 1; k --)
        {
            for(int t = 1; t <= k; t ++)
            {
                dp[root][k][0] = max(dp[root][k][0],dp[son][t - 2][0] + dp[root][k - t][0]);
                dp[root][k][1] = max(dp[root][k][1],dp[son][t - 1][1] + dp[root][k - t][0]);
                dp[root][k][1] = max(dp[root][k][1],dp[son][t - 2][0] + dp[root][k - t][1]);
            }
        }
    }
}
int main()
{
    while(~scanf("%d%d",&N,&M))
    {
        memset(dp,0,sizeof(dp));
        for(int i = 1; i <= N; i ++)
        {
            scanf("%d",&weight[i]);
            Q[i].clear();
            for(int j = 0; j <= M; j ++)
            {
                dp[i][j][0] = dp[i][j][1] = weight[i];//初始化每一个值。
            }
        }
        for(int i = 1; i < N; i ++)
        {
            int a,b;
            scanf("%d%d",&a,&b);
            Q[a].push_back(b);
            Q[b].push_back(a);
        }
        dfs(1,0);
        printf("%d\n",max(dp[1][M][0],dp[1][M][1]));
    }
}

题目链接：http://poj.org/problem?id=3140
这道题十分简单。但是要注意爆int，所以最大值的初始值一定要大。 我就是因为这个wa了。
这道题，用一个dp[i]表示i这颗子树上有多少个节点。那么其他的节点个数不就是总节点个数减去dp[i]吗。 所以我们把每个子树的节点个数求出来并比较就可以了。

#include"stdio.h"
#include"string.h"
#include"vector"
#include"math.h"
#include"algorithm"
using namespace std;
typedef long long ll;

ll N,M,sum,minx;
ll dp[100010],weight[100010];
vector<ll>Q[100010];
ll abs1(ll sum)
{
    if(sum < 0) sum = (ll)-1 * sum;
    return sum;
}
ll dfs(ll root,ll pre)
{
    if(dp[root] != 0)    return dp[root];
    dp[root] = weight[root];
    for(int i = 0; i < Q[root].size(); i ++)
    {
        ll v = Q[root][i];
        if(v == pre) continue;
        dp[root] += dfs(v,root);
    }
    if(abs1(sum - dp[root] - dp[root]) < minx)
        minx = abs1(sum - dp[root] - dp[root]);
    return dp[root];
}

int main()
{
    int cnt = 1;
    while(scanf("%lld%lld",&N,&M))
    {
        if(N + M == 0) break;
        sum = 0; minx = 1000001010000000;//一定要大点，不然爆
        for(int i = 1; i <= N; i ++)
        {
            scanf("%lld",&weight[i]);
            sum += weight[i];
            dp[i] = 0;
            Q[i].clear();
        }
        while(M --)
        {
            ll a,b; scanf("%lld%lld",&a,&b);
            Q[a].push_back(b);
            Q[b].push_back(a);
        }
        for(int i = 1; i <= N;i ++)
        {
            memset(dp,0,sizeof(0));
            dfs(i, 0);
        }
        printf("Case %d: %lld\n",cnt++,minx);
    }
}

题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=1520
这个题意就是说如果选了他的上司就不能选他，反之，选了他，就不能选他的上司，问最多能选多少个人。
我们可以看到，对于每一个人来说存在两种可能，1，选他，2，不选。
所以我们可以定义一个dp[n][2] 这样的一个dp数组来做这道题目。
dp[i][0]表示不选第i个节点，则他的子树最多能选多少个节点。
dp[i][1]表示选了dii个节点，则他的子树最多能选多少个节点。
则状态转移方程就已经出来了。
dp[i][0] += max(dp[v][0],dp[v][1])
dp[i][1] += dp[v][0];
至于第一个方程为什么要用max，可以这么说，就是有可能存在i点不选 v点不选 选了v点的子节点，反而值会更大的情况。 这个情况很简单就能想到了，就不过多复述。

第二个方程就跟简单了。
代码：

#include"stdio.h"
#include"string.h"
#include"vector"
#include"algorithm"
using namespace std;

int dp[6010][2],weight[6010],n,in[6010];
int vis[6010];
vector<int>Q[6010];

void dfs(int root)
{
    dp[root][0] = 0 ;
    dp[root][1] = weight[root];
    for(int i = 0; i < Q[root].size(); i ++)
    {
        int v = Q[root][i];
        if(vis[v] == 0)
           {
               dfs(v);
               vis[v] = 1;
           }
        dp[root][0] += max(dp[v][0],dp[v][1]);
        dp[root][1] += dp[v][0];
    }
}

int main()
{
    while(~scanf("%d",&n))
    {
        for(int i = 1; i <= n; i ++)
            {
                scanf("%d",&weight[i]);
                Q[i].clear();
            }
        memset(dp,0,sizeof(dp));
        memset(in,0,sizeof(in));
        memset(vis,0,sizeof(vis));
        while(1)
        {
            int a,b;
            scanf("%d%d",&a,&b);
            if(a == 0 && b == 0)
                break;
            Q[b].push_back(a);
            in[a]++;
        }
        int root = 0;
        for(int i = 1; i<= n; i ++)
            if(in[i] == 0)
            {
                root = i;
                break;
            }
        dfs(root);
        printf("%d\n",max(dp[root][0],dp[root][1]));
    }
}

题目链接：http://poj.org/problem?id=1463
这个题同上题。但是不知道为什么，我觉得这个题的题面有点问题，还是我自己理解的问题。 我自己造的一组数据，用我这个代码是过不了的。 但是这个代码是AC的。而且网上大部分也都是这个思路。

#include"stdio.h"
#include"string.h"
#include"vector"
#include"algorithm"
using namespace std;

int n,dp[1510][2],in[1510];
vector<int>Q[1510];

void dfs(int root)
{
    for(int i = 0; i < Q[root].size(); i ++)
    {
        int v = Q[root][i];
        dfs(v);
        dp[root][1] += min(dp[v][0],dp[v][1]);
        dp[root][0] += dp[v][1];
    }
}

int main()
{
    while(~scanf("%d",&n))
    {
        memset(dp,0,sizeof(dp));
        memset(in,0,sizeof(in));
        for(int i = 1; i <= n; i ++) Q[i].clear();
        for(int i = 1; i <= n; i ++)
        {
            int id,cnt;
            scanf("%d",&id);
            id++;
            scanf(":(%d)",&cnt);
            while(cnt --)
            {
                int a;
                scanf("%d",&a);
                a++;
                Q[id].push_back(a);
                in[a]++;
            }
            dp[i][0] = 0; dp[i][1] = 1;
        }
        int root = -1;
        for(int i = 1; i <= n; i ++)
            if(in[i] == 0)
            {
                root = i; break;
            }
        dfs(root);
        printf("%d\n",min(dp[root][1],dp[root][0]));
    }
}
/*10
0:(2) 1 2
1:(1) 4
2:(3) 7 8  9
3:(0)
4:(3) 3 5 6
5:(0)
6:(0)
7:(0)
8:(0)
9:(0)*/
//自己画图结果应该为2 但是输出3 

望有大佬见到告知

题目连接：http://acm.hdu.edu.cn/showproblem.php?pid=1561
这个题目的话，个人觉得用左儿子，右兄弟的方法做简单易懂的。其实也是一道树上背包问题。
左儿子，右兄弟的意思是，定义一个儿子数组和兄弟数组。
利用这两个数组来进行dp。
dp[i][M]= max(ans,dfs(son[root],k) + dfs(bro[root],M - 1 - k) + weight[root]);
这个表示，在第i个结点的子树上能攻打M个城堡。但是注意，这M个城堡，可以分给他的儿子也可以分给他的兄弟。所以我们需要枚举k的大小，从而得到最优解。
代码：

#include"stdio.h"
#include"string.h"
#include"algorithm"
using namespace std;
int N,M;
int son[210],bro[210];
int dp[210][210],weight[210];

int dfs(int root,int M)
{
    if(root == -1) return 0;
   // printf("root = %d\n",root);
    if(dp[root][M] != -1) return dp[root][M];
    int ans = dfs(bro[root],M);
    for(int k = 0; k <= M - 1; k ++)
    {
        ans = max(ans,dfs(son[root],k) + dfs(bro[root],M - 1 - k) + weight[root]);
    }
    return  dp[root][M] = ans;
}
int main()
{
    while(~scanf("%d%d",&N,&M))
    {
        if(N == 0 && M == 0) break;
        memset(son,-1,sizeof(son));
        memset(bro,-1,sizeof(bro));
        memset(dp,-1,sizeof(dp));
        memset(weight,0,sizeof(weight));
        for(int i = 1; i <= N; i ++)
        {
            int a,b; scanf("%d%d",&a,&b);
            weight[i] = b;
            if(son[a] == -1)//这里是建立左儿子右兄弟的关键。
                son[a] = i;
            else
            {
                bro[i] = son[a];
                son[a] = i;
            }
        }
        int maxx = dfs(son[0],M);
        /*for(int i = 0; i <= N; i ++)
        {
            for(int j = 0; j <= N; j ++)
                printf("%d ",dp[i][j]);
            printf("\n");
        }*/
        printf("%d\n",maxx);
    }
}

博主水平有限，许多地方也未叙述清楚。附上，学习树形dp的参考博客和有关视频，望对各位有所帮助。
参考博客：https://blog.csdn.net/dcx2001/article/details/78269908
视频：https://www.bilibili.com/video/av22695258?t=4289
https://www.bilibili.com/video/av12194537?t=2043