初学树型dp

树型DP

DFS的回溯是树形DP的重点以及核心，当回溯结束后，root的子树已经被遍历完并处理完了。这便是树形DP的最重要的特点

自己认为应该注意的点

1. 好多人都说在更新当前节点时，它的儿子结点都给更新完了，实际上这并不准确。对于当前节点，我们需要dfs它的儿子，并且在dfs中进行dp。在此过程中并不是等到儿子都更新完我们才更新当前节点的信息（假设当前节点为x, 有儿子son1 , son2, son3， 且son1已经更新完了， 即x已有了son1的信息， son2刚刚更新完，即dfs正在son2的位置回溯）， 我们拿着son2， x和son1的信息再次更新x， 如此，x才有了son1,son2的综合信息，之后再从son3 dfs进去找son3的信息，最后才得到x的信息。
2. 需要注意枚举的顺序，树型dp有点像01背包，而01背包更新信息时你如果没有记录对于i，i中前j个的状态，你就需要倒序枚举，而树型dp中通常直接用f[x] [...]...表示x所在子树的信息，这里枚举k的时候就需要像01背包一样了，从size[x]逆序枚举。

（01背包倒着写时要倒序，不然就表示可以多次使用前面的物品更新后面的物品的状态（比如你顺着写，你第j个物品用到了前j个物品来更新，那当你再用第j个物品更新第j+1个物品时，又把前面的算了一遍，所以就算重复了），这不就成了完全背包嘛，我们的01背包倒着写是为了每次更新，都是取用它前面的状态，而它前面的状态又是没改过的，所以不会选重。树型dp同理，用前j个儿子更新第j+1个儿子时不能选重复）

梨提

luoguP1352 没有上司的舞会(熟悉一下回溯)

https://www.luogu.org/problemnew/show/P1352

/*
f[i] [0/1] 0与1分别表示第i个人不去，去时的最大快乐指数
所以 f[i] [0] += max（ f[son] [1] ,f[son] [0]）;
f[i] [1] += max(f[son] [0] , 0)

1. 为什么f[i][1] 要与0 做比较? : 因为快乐指数可能是负的

2. 为什么f[i][0] 不用与0作比较，直接＝max？：就算是负的，也只能直接去最大的，他又不去．．．　

3. 为什么是+=？ ： 下面有

*/

#include <cstdio>
#include <algorithm>
using namespace std;
const int MAXN = 6000+9;

int n,cnt;
int head[MAXN];
int R[MAXN],f[MAXN][2],fa[MAXN]; 

struct edge{
    int y,next;
}e[MAXN];

void add_edge(int x, int y) {
    e[++cnt].y = y;
    e[cnt].next = head[x];
    head[x] = cnt;
}

void dfs(int now) {
    f[now][1] = R[now];
    f[now][0] = 0;//初始化
    for(int i = head[now]; i; i = e[i].next ) {//i是边编号 
        int nn = e[i].y ;
        dfs(nn);//先递归进去处理儿子的f值 
        f[now][0] += max(f[nn][1] ,f[nn][0]) ;
        f[now][1] += max(f[nn][0] , 0);
    //注：因为一棵树可能有多个儿子，所以这里都是+=; 
    }
}

int main() {
    scanf("%d",&n);
    for(int i = 1; i <= n; i++) {
        scanf("%d",&R[i]);
    }
    int l,k;
    for(int i = 1; i <= n; i++) {
        scanf("%d%d",&l,&k);
        if(i == n) break;//只输入了n-1行 
        fa[l] = k;
        add_edge(k,l);
    }
    int root;
    for(int i = 1; i <= n; i++) if(!fa[i]) {
        root = i;
        break;//找根
    }
    dfs(root);
    int ans = max(f[root][0],f[root][1]);
    printf("%d",ans);
}

luoguP2014 选课(注意树型dp要符合dp的特点)

https://www.luogu.org/problem/P2014

注意枚举当前节点所选的课要倒序枚举，原因同上

#include<cstdio>
#include<algorithm>
using namespace std;
const int MAX = 300+9;

int n,m;
int f[MAX][MAX], arr[MAX], size[MAX];
//f[i][j]表示子树i中(包括i)选j门课的最大学分 

struct edge{
    int y, next;
}e[MAX<<1];
int head[MAX], cnt;
void add_edge(int x, int y) {
    e[++cnt].y = y;
    e[cnt].next = head[x];
    head[x] = cnt;
}

void dfs(int x) {
    size[x] = 1;
    for(int i = head[x]; i; i = e[i].next) {
        dfs(e[i].y);
        size[x] += size[e[i].y];
        for(int k = size[x]; k >= 1; k--) {//父亲不选就都不能选，所以>=1//这儿的k必须倒序
            for(int j = 0; j < k; j++) {//枚举在当前儿子中选的课
                f[x][k] = max(f[x][k],f[x][k-j] + f[e[i].y][j]);
            }
        }
    }
}

int main() {
    scanf("%d%d",&n,&m);
    int x;
    for(int y = 1; y <= n; y++) {
        scanf("%d%d",&x,&arr[y]);
        add_edge(x,y);
    }
    m++;
//  f[0][1] = 0;
    for(int i = 1; i <= n; i++) f[i][1] = arr[i];
    dfs(0);
    printf("%d",f[0][m]);
}

luoguP2015 二叉苹果树

注： 因为相当于0-1背包中的选或不选，所以 j 是逆序的，其他细节在代码里有体现和解释

https://www.luogu.org/problemnew/show/P2015

#include<cstdio>
#include<algorithm>
using namespace std;
const int MAXN = 100+9;

int n,Q;
int f[MAXN][MAXN];//f[i][j]表示： 点i和它的子树保留j个树枝时的最大苹果数 
int head[MAXN],cnt;

struct edge{
    int y,val,next;
}e[MAXN];

void add_edge(int x, int y, int val) {
    e[++cnt].y = y;
    e[cnt].val = val;
    e[cnt].next = head[x];
    head[x] = cnt;
} 

void dfs(int now ,int dad) {
    f[now][0] = 0;//初始化边界
    for(int i = head[now]; i; i = e[i].next ) {
        int nn = e[i].y ;
        if(nn == dad) continue ;//应该是continue吧，不是return ； 
        dfs(nn, now);//先递归进去处理儿子的f值 
        for(int j = Q; j; j--) {//逆序的原因: 0-1背包选或不选 
            for(int k = 0; k < j; k++) {//枚举 左/右 子树保留的树枝
                f[now][j] = max(f[now][j], f[now][j-k-1] + f[nn][k] + e[i].val );
                                            //要选子树nn上边，就要把子树nn与根的边选上，所以这里是j-k还要"-1" 
            }
        }
    }
}

int main() {
    scanf("%d%d",&n,&Q);
    int m = n-1;//二叉树的边 
    for(int i = 1, x, y, val; i <= m; i++) {
        scanf("%d%d%d",&x,&y,&val);
        add_edge(x,y,val);
        add_edge(y,x,val);//只是描述了边，但不知道父亲是谁，儿子是谁,所以建双向的
        //所以下面的dfs要开一个树根的形参，防止死循环 
    }
    //1为根
    dfs(1,1);
    printf("%d",f[1][Q]);
    return 0;
}

luoguP1270 “访问”美术馆

转载于:https://www.cnblogs.com/tyner/p/11396627.html