树上DP入门题 - 二叉苹果树

https://www.luogu.com.cn/problemnew/solution/P2015

解法1:记忆化搜索

#include <iostream>
#include <cstring>
#include <vector>
#define MAX(a,b) (a>b?a:b)
#define Maxsize 100+1
using namespace std;
struct node{
    int id;
    int val;
    node(int a,int b){
        id = a;val = b;
    }
};
int dp[Maxsize][Maxsize]; // 以第i个顶点作为根节点,保留至多j个枝条，所能得到的最大答案
bool vis[Maxsize];
vector<node> tree[Maxsize];
vector<node> temp[Maxsize];
void build_tree(int x){
    vis[x] = true;
    for (auto it = temp[x].begin(); it != temp[x].end(); it++) {
        if(!vis[it->id]){
            tree[x].push_back(*it);
            build_tree(it->id);
        }
    }
}
int fun(int x,int num){ // 以第i个顶点作为根节点,保留至多j个枝条，所能得到的最大答案
    if (dp[x][num] != -1) {
        return dp[x][num];
    }else if(tree[x].empty() || num == 0){
        return 0;
    }else{
        int p1 =  MAX(fun(tree[x][0].id,num-1)+tree[x][0].val,fun(tree[x][1].id,num-1)+tree[x][1].val); // 二选一
        int p2 = 0;
        for (int i = 1; i <= num - 1; i++) {
            int j = num - i;
            int temp = fun(tree[x][0].id,i-1) + tree[x][0].val + fun(tree[x][1].id,j-1) + tree[x][1].val;
            p2 = MAX(p2,temp);
        }
        return dp[x][num] = MAX(p1,p2);
    }
}
int main(){
    int n,q;
    int a,b,c;
    cin >> n >> q;
    for (int i = 1; i < n; i++) {
        cin >> a >> b >> c;
        temp[a].push_back(node(b,c));
        temp[b].push_back(node(a,c));
    }
    memset(dp,-1,sizeof(dp));
    build_tree(1);
    cout << fun(1,q);
    return 0;
}

解法2:树上DP

由于数据结构是一棵树，导致我们不能用常规的方式去DP。这是因为，由状态转移方程可知，每一个子问题都要用到当前根节点的子孙的结果。因此，我们需要依靠dfs，先解决子问题，再回溯求解原问题。

注意，dfs仅仅只是我们到达子问题的手段，而求解问题的核心方式还是DP。它与记忆化搜索都用到了dfs，但有着很大的区别。

#include <iostream>
#include <vector>
#define MAX(a,b) (a>b?a:b)
#define Maxsize 100+1
using namespace std;
int n,q;
int dp[Maxsize][Maxsize];
struct node{
    int id;
    int val;
    node(int a,int b){
        id = a; val = b;
    }
};
bool vis[Maxsize];
vector<node> tree[Maxsize];
void dfs(int x){
    vis[x] = true;
    for (auto it = tree[x].begin(); it != tree[x].end(); it++) {
        if(!vis[it->id]){
            vis[it->id] = true;
            dfs(it->id);
            vis[it->id] = false;
        }
    }
    if(tree[x].size()==1){
        return;
    }else{
        vector<int> m;
        vector<int> v;
        for (auto it = tree[x].begin(); it != tree[x].end(); it++) {
            if(!vis[it->id]){
                m.push_back(it->id);
                v.push_back(it->val);
            }
        }
        for (int i = 1; i <= q; i++) { // 至少也有一个出边 , 一个也没用的话,答案不用算肯定是0
            int p1 = MAX(dp[m[0]][i-1]+v[0],dp[m[1]][i-1]+v[1]);
            for (int j = 1; i-j >= 1; j++) {
                dp[x][i] = MAX(dp[x][i],dp[m[0]][j-1]+v[0]+dp[m[1]][i-j-1]+v[1]);
            }
            dp[x][i] = MAX(dp[x][i],p1);
        }
    }
}
int main(){
    int a,b,c;
    cin >> n >> q;
    for (int i = 1; i < n; i++) {
        cin >> a >> b >> c;
        tree[a].push_back(node(b,c));
        tree[b].push_back(node(a,c));
    }
    dfs(1);
    cout << dp[1][q];
    return 0;
}