《算法：生产车间》

生产车间

思路讲解

先以样例来做理解

可以把叶子节点权重看作输出，而其他节点则是能接收多大的值，最后算出根节点能拿到的最大的值

先找到叶子节点并且把能传递的值和多个叶子节点叠加的值存到6节点中

再继续计算2节点能传递的节点值，注意，2和4值都属于6节点，不能相加，这里就涉及到分组问题

最后算出根节点从左右节点中能拿到的最大值

我们总结思路，判断该用什么算法来做：

核心是以链表形式来查找叶子节点已经其他节点所能传递的值
查找每个节点的能传递的值这个过程用到深度搜索dfs
存储每个节点的能传递的值则用到动态规划的分组操作（分组背包）

树形dp

状态表示：bool dp[s][i]表示：s（son）节点存储了哪些可以传递的值，i是否能向上传递
状态转移方程：dp[s][i] = dp[s][i] || (dp[x][j] && dp[s][i - j]); s节点的i值是否能向上传递的条件为：两个子节点的值都能向上传递：dp[子节点][子节点的值] && dp[父节点][父节点已经存储的值] （这里已经做了范围处理，不会超过阈值）
初始化：dp[s[[0] = true : 0值都能向上传递

cpp 复制代码

#include <iostream>
#include <vector>
#include <bitset>
using namespace std;
const int N = 1001;
vector<vector<int>> path(N); //双向存储父子节点的联系
bool dp[N][N];
int n, w[N];

void dfs(int s, int f) {
    dp[s][0] = true;
    if (path[s].size() == 1 && s != 1) { // 1
        dp[s][w[s]] = true;
        return;
    }
    
    for (auto x : path[s]) {
        if (x == f) continue; // 双向存储，如果存储的节点是父节点则跳过
        dfs(x, s);
        
        for (int i = w[s]; i >= 0; i--) { // 2
            for (int j = min(i, w[x]); j >= 0; j--) { // 3
                dp[s][i] = dp[s][i] || (dp[x][j] && dp[s][i - j]);
            }
        }
    }
    return;
}

int main() {
    cin >> n;
    for (int i = 1; i <= n; i++) cin >> w[i];
    
    for (int i = 1; i < n; i++) {
        int a, b; cin >> a >> b;
        path[a].emplace_back(b);
        path[b].emplace_back(a);
    }
    
    dfs(1, 0);

    for (int i = w[1]; i >= 0; i--) {
        if (dp[1][i]) {
            cout << i;
            break;
        }
    }
    return 0;
}

注意事项：

if (path[s].size() == 1 && s != 1)查找该节点是否为叶子节点并且他不是父节点（这里存储做的是双向存储，父节点的节点数也为可能1）
for (int i = w[s]; i >= 0; i--) 先从大到小循环当前要查找的节点它能向上传递的权值
for (int j = min(i, w[x]); j >= 0; j--)再查找它的子节点能向上传递的权重，将它们进行整合存储

cpp 复制代码

#include <iostream>
#include <vector>
#include <bitset>
using namespace std;
const int N = 1001;
vector<vector<int>> path(N);
//bool dp[N][N];
bitset<N> dp[N];
int n, w[N];

void dfs(int s, int f) {
    dp[s][0] = true;
    if (path[s].size() == 1 && s != 1) {
        dp[s][w[s]] = true;
        return;
    }
    
    for (auto x : path[s]) {
        if (x == f) continue;
        dfs(x, s);
        
        // for (int i = w[s]; i >= 0; i--) {
        //     for (int j = min(i, w[x]); j >= 0; j--) {
        //         dp[s][i] = dp[s][i] || (dp[x][j] && dp[s][i - j]);
        //     }
        // }
        bitset<N> f = dp[s];
        for (int i = w[x]; i >= 0; i--) {
            if (dp[x][i]) dp[s] |= f << i;
        }
    }
    return;
}

int main() {
    cin >> n;
    for (int i = 1; i <= n; i++) cin >> w[i];
    
    for (int i = 1; i < n; i++) {
        int a, b; cin >> a >> b;
        path[a].emplace_back(b);
        path[b].emplace_back(a);
    }
    
    dfs(1, 0);

    for (int i = w[1]; i >= 0; i--) {
        if (dp[1][i]) {
            cout << i;
            break;
        }
    }
    return 0;
}