树形dp_自上而下树形dp-CSDN博客

本文链接：https://blog.csdn.net/u011612364/article/details/114851939

总结

一般来说树形dp实现时一般都是用子树更新父亲（即从下向上更新）。

树形dp的主要实现形式是dfs，在dfs中dp，主要的实现形式是dp[i][j][0/1]，i是以i为根的子树，j是表示在以i为根的子树中选择j个子节点，0表示这个节点不选，1表示选择这个节点。有的时候j或0/1这一维可以压掉。

关于建树，以及遍历的代码其实是非常套路化了，邻接表建树。

一般来说有两种情况：
1.需要把所有子树的信息都掌握之后再更新子树的就需要把所有子树都算完了在更新父亲。

2.像树上背包这样的问题就需要一个一个的更新，每次都用一个子树更新已经更新完的子树+父亲，最后就可以将这一部分的子树更新完了，再继续往上更新，最后根节点就是答案。

例题

P1352

一个经典的入门题没有上司的舞会https://www.luogu.com.cn/problem/P1352

思路：

用dp[i][0/1]表示编号为i的点选或不选时，以它为根的子树的最大活跃值。

看了别人的转移方程发现我写复杂了，因为我考虑到了还有负数的活跃值，所以对于不选的初始化是 $- I N F$ ，不过一样也是对的。

但是其实负数完全可以不选就完了，所以还是从0开始的。

转移方程： $dp[x][0]+=dp[v][1]\\ dp[x][1]+=min(dp[v][0],dp[v][1])$
代码：

#include<bits/stdc++.h>
#include<iostream>
#include <stdio.h>
using namespace std;
const int maxn=60005;
const int base=131;
typedef long long ll;
#define pi acos(-1)
#define INF 0x3f3f3f3f
#define mod 998244353
const int inf=1<<30;
int r[maxn];
int dp[maxn][2];
vector<int> g[maxn];
void dfs(int u,int fa)
{
    dp[u][1] = r[u];
    dp[u][0] = -INF;
    for(int i =0; i< g[u].size(); i++){
        int v = g[u][i];
        if(v == fa)
            continue;
        dfs(v,u);
        dp[u][1] = max(dp[u][1], dp[u][1] + dp[v][0]); 
        if(dp[u][0] == -INF) dp[u][0] = max(dp[v][1],dp[v][0]);      
        else dp[u][0] = max(dp[u][0], dp[u][0] + max(dp[v][1],dp[v][0]));
    }
}

int main()
{
    //freopen("data.in","r",stdin);
    //freopen("1.out","w",stdout);
    ios::sync_with_stdio(false); cin.tie(0);
    int n;
    cin>>n;
    for(int i = 1;i <= n; i++)
        cin>>r[i];
    int l,k;
    int r = (1 + n) * n / 2;
    for(int i =1; i < n; i++){
        cin>>l>>k;
        r -= l;
        g[l].push_back(k);
        g[k].push_back(l);
    }
    // cout<<r<<endl;
    dfs(r,-1);
    cout<<max(dp[r][0],dp[r][1])<<endl;
    return 0;
}

旅游

这个是我第一次接触树形dp做的题，之前的题解链接：https://blog.csdn.net/u011612364/article/details/108609766

发现这个和上题的转移方程是一摸一样的，对于这一类选点
类问题他们的转移方程都是:
$\left\{ \begin{array}{l} dp[x][0]=dp[v][1]\\ dp[x][1]=max/min(dp[v][0],dp[v][1]) \end{array} \right.$
下面引入更难的问题

HANI2015树上染色

链接：https://ac.nowcoder.com/acm/problem/19996

思路：

这个题还是比较容易想到dp，用 $d p [i] [j]$ 表示第i点为根的子树下选了j个点涂为黑色的最大收益，但是问题在于怎么计算状态转移的时候增加的距离。

方法是对于每一条边，计算边的长度对答案的贡献，也就是对于点V，V两边的黑点和黑点，白点和白点，两两之间都需要经过这条边（u，v），如果V的子树上有m个黑点，那么贡献就是 $m\times(k-m) +(siz[v]-m)*(n-siz[v]-k+m)\times dis$
其中， $s i z [v]$ 是以v为子树的树的节点数,dis是这条边的长度。

那么状态转移方程就是 $d p [u] [j] = m a x (d p [u] [j], d p [v] [m] + d p [u] [j - m] + c a l (m, s i z [v]) * n o . d i s)$

对于这个方程怎么更新困扰了我很久，其实正序更新就相当于用这一轮的值来更新，倒叙更新就是用上一轮的值来更新。

显然对于对于u的子树上黑点的数量j来说，我们在后面更新的时候还要用上一轮的值，所以果断倒叙。

而对于内层循环的v的子树黑点的数量m来说，更新dp[u][j]需要用到dp[u][j-m]，所以dp[u][j-m]的值是在前更新的，也就是m应该正序从0开始增加。（不过我看了下别人的题解发现倒叙枚举也是可行的，只要将m=0的状态先转移过来就行了）

#include<bits/stdc++.h>
#include<iostream>
#include <stdio.h>
using namespace std;
const int maxn=2005;
const int base=131;
typedef long long ll;
#define pi acos(-1)
#define INF 0x3f3f3f3f
#define mod 998244353
const int inf=1<<30;
ll dp[maxn][maxn];
int siz[maxn];
int n,k;
ll ans = 0;

struct node
{
    int f,t;
    ll dis;
};

vector<node> g[maxn];

ll cal(int x,int y)
{
    return 1ll *x * (k - x) + (y - x) * (n - y - k +x);
}

void dfs(int u,int fa)
{
    siz[u] = 1;
    dp[u][0] = dp[u][1] = 0;
    for(int i = 0;i < g[u].size(); i++){
        node no = g[u][i];
        int v = no.t;
        if(v == fa)
            continue;
        dfs(v,u);
        siz[u] += siz[v];
        for(int j = min(k,siz[u]);j >= 0; j--){
            for(int m = 0; m <= min(j,siz[v]) ; m++){
                dp[u][j] = max(dp[u][j],dp[v][m] + dp[u][j - m] + cal(m,siz[v]) * no.dis);
            } 
        }
    
    }
}

int main()
{
    //freopen("data.in","r",stdin);
    //freopen("1.out","w",stdout);
     ios::sync_with_stdio(false); cin.tie(0);
    cin>>n>>k;
    memset(dp,-INF,sizeof(dp));
    int r = (1 + n) * n / 2;
    for(int i = 1;i < n; i++){
        node n1,n2;
        cin>>n1.f>>n1.t>>n1.dis;
        r -= n1.t; 
        n2.f = n1.t;
        n2.t = n1.f;
        n2.dis = n1.dis;
        g[n1.f].push_back(n1);
        g[n2.f].push_back(n2);
    }
    dfs(1,-1);
    //dfs1(r,-1);
    cout<<dp[1][k]<<endl;
    return 0;
}