树形dp(c++)

记录一下这两个题目的区别
选课

for (int j = x + 1; j >= 0; j--) { 
			for (int k = j - 1; k >= 0; k--) {
				f[u][j] = max(f[u][j], f[u][j - k] + f[t][k] + v[t]);  
			}             
		}                 

二叉苹果树

	for (int j = x; j >= 1; j--) { 
			for (int k = j - 1; k >= 0; k--) { 
				f[u][j] = max(f[u][j], f[u][j - k - 1] + f[t][k] + T[u][i].val);
			} 
		}

二叉苹果树是选择边， 而选课是选择点
如果先写了选课再去写二叉苹果树，那么在写状态转移方程的时候就可能会混淆
```cpp
f[u][j] = max(f[u][j], f[u][j - k] + f[t][k] + v[t]);   //选课
f[u][j] = max(f[u][j], f[u][j - k - 1] + f[t][k] + T[u][i].val);  //二叉苹果树

`f[u[[j]`在以 u 为根结点的树上选了j门课（包括u）能获得的最多学分
选课(选结点)：在以u为根结点的树上选了 j 门课（包括 u ）,分k门给u当前处理的子结点t
那么还剩 j - k门课， 如果 j - k = 1， 那么 j - k分给根结点对应的课， 如果 j - k > 1，那么 j - k 分给根结点 u 对应的课以及根结点的子节点对应的课
比如j = 3, 那么k = 2

f[u][3] = max(f[u][3], f[u][1] + f[t][2] + v[t]); 
//f[u][1]表示在以u为根结点的树上选了一门课（f[u][1]在输入时便已经初始化为u对应的课的学分）
//即这门课就是根结点u对应的课
//f[t][2]表示在以t为根结点的树上选了2个结点
//v[t]表示t对应的课的分数

`f[u[[j]`以u为根结点,连接j条边（直接连接或者通过子结点间接连接）能获得的最大苹果数
二叉苹果树（选边）：`f[u[[j]`以 u 为根结点,连接j条边（直接连接或者通过子结点间接连接），
u 可以连接（直接或者间接）j 条边， 分了 k 条给当前处理的u的子结点t，还剩 j - k条
假如 j = 3， 那么k = 2

f[u][3] = max(f[u][3], f[u][0] + f[t][2] + T[u][i].val);  //二叉苹果树
//f[u][0]表示以u为根节点， 连接0条边的最大苹果数
//f[t][2]表示以t为根节点连接2条边的最大苹果数
//T[u][i].val表示以u为起点，t为终点的边的边权

二叉苹果树

题目描述

有一棵苹果树，如果树枝有分叉，一定是分二叉（就是说没有只有一个儿子的结点）

这棵树共有 N个结点（叶子点或者树枝分叉点），编号为 1∼N，树根编号一定是 1。

我们用一根树枝两端连接的结点的编号来描述一根树枝的位置。下面是一颗有 4 个树枝的树：

2   5
 \ / 
  3   4
   \ /
    1

现在这颗树枝条太多了，需要剪枝。但是一些树枝上长有苹果。

给定需要保留的树枝数量，求出最多能留住多少苹果。

输入格式

第一行 2 个整数 N和 Q，分别表示表示树的结点数，和要保留的树枝数量。

接下来 N−1行，每行 3个整数，描述一根树枝的信息：前 2个数是它连接的结点的编号，第 3个数是这根树枝上苹果的数量。

输出格式

一个数，最多能留住的苹果的数量。

输入输出样例

**输入 **

5 2
1 3 1
1 4 10
2 3 20
3 5 20

**输出 **

21

说明/提示

1⩽Q<N⩽100，每根树枝上的苹果 ⩽3×10^4。

#define _CRT_SECURE_NO_WARNINGS 1
#include<bits/stdc++.h>
using namespace std;
struct Node {
	int end;
	int val;
};
void dfs(int u, vector<Node> * T, vector<vector<int>> & f, int x, vector<int> & vis) {
	vis[u] = 1;
	for (int i = 0; i < T[u].size(); i++) {
		int t = T[u][i].end;
		if (vis[t]) {
			continue;
		}
		dfs(t, T, f, x, vis);
		for (int j = x; j >= 1; j--) {  //遍历父结点可能连接的边数，最少一条（这里的连接，如果只是一条那就是直接连接，如果>1条就说明是间接连接， 中间有子结点）
			for (int k = j - 1; k >= 0; k--) {  //遍历子结点可能连接的边数最少0条， 最多j - 1条
				f[u][j] = max(f[u][j], f[u][j - k - 1] + f[t][k] + T[u][i].val);
			}  //这里就是个背包问题， 
		}

	}
}
int main() {
	int n, x;
	cin >> n >> x;
	vector<int> vis(n + 1, 0);
	vector<Node> T[n + 1];
	vector<vector<int>> f(n + 1, vector<int>(x + 1, 0));  //f[u][i]表示以u为根结点，保留i条边能获得的最大的苹果数
	for (int i = 1; i < n; i++) {
		int a, b, c;
		cin >> a >> b >> c;
		Node node = { b, c };
		T[a].push_back(node);
		node = { a, c };
		T[b].push_back(node);
	}
	dfs(1, T, f, x, vis);
	printf("%d", f[1][x]);
	return 0;
}

P2014 选课

题目描述

在大学里每个学生，为了达到一定的学分，必须从很多课程里选择一些课程来学习，在课程里有些课程必须在某些课程之前学习，如高等数学总是在其它课程之前学习。现在有 N门功课，每门课有个学分，每门课有一门或没有直接先修课（若课程 a 是课程 b 的先修课即只有学完了课程 a，才能学习课程 b）。一个学生要从这些课程里选择 M门课程学习，问他能获得的最大学分是多少？

输入格式

第一行有两个整数 N, M用空格隔开。( 1≤N≤300, 1≤M≤300)

接下来的 N行,第 I+1行包含两个整数 ki和 si, ki 表示第i门课的直接先修课，si表示第I门课的学分。若 ki=0表示没有直接先修课（1≤ki≤N , 1≤si≤20）。

输出格式

只有一行，选 M门课程的最大得分。

输入输出样例

**输入 **

7  4
2  2
0  1
0  4
2  1
7  1
7  6
2  2

**输出 **

13

#define _CRT_SECURE_NO_WARNINGS 1
#include<bits/stdc++.h>
using namespace std;
int n, x;
void dfs(int u, vector<int>& v, vector<int>& vis, vector<int>* T, vector<vector<int>>& f) {
	vis[u] = 1;
	for (int i = 0; i < T[u].size(); i++) {
		int t = T[u][i];
		if (vis[t]) {
			continue;
		}
		dfs(t, v, vis, T, f);               //f[i][j]表示在子树i中选了j门课的最大学分（包括本身）  在以0为根结点的数中选x + 1门课（这里的x + 1是专门为结点0设计的)
		for (int j = x + 1; j >= 0; j--) { 
			for (int k = j - 1; k >= 0; k--) {   //以u为根结点的树中选j门课（u也算在j里面）， 这里k = j - 1是因为默认已经选了u(f[u][1]已经初始化为对应的值了)
				f[u][j] = max(f[u][j], f[u][j - k] + f[t][k] + v[t]);  
			}               //在结点u上选了j门课（包括u）， 分出去k门，剩下j - k
		}                   //如果j - k等于1，就表示剩下的这一门是u， 如果j - k > 1就表示 其中一门是u， 剩下的是u的其他子结点
	}
}
int main() {
	cin >> n >> x;
	vector<int> v(n + 1, 0);
	vector<int> vis(n + 1, 0);
	vector<int> T[n + 1];
	vector<vector<int>> f(n + 1, vector<int>(n + 1, 0));
	for (int i = 1; i <= n; i++) {
		int a, b;
		cin >> a >> b;
		T[a].push_back(i);
		f[i][1] = b;
	}
	for (int i = 0; i <= n; i++) {
		dfs(0, v, vis, T, f);
		printf("%d", f[0][x + 1]);
		return 0;
	}
	return 0;
}