明天开学
问题模型一般是：
给定n个物品，有一个容积为V的背包，每个物品依赖一个物品，选择一个必须选择所依赖的物品，依赖关系构成一棵树，每个物品有体积，价值，最大化价值；
这种模型称作树形有依赖背包问题;
常见方法大概有三种：
1.多叉树转化为二叉树：
将一个节点的多个儿子中选择最左的儿子保留下来，剩下的儿子放到左儿子的右子树里；
来张图片：
状态转移即为：
设dp[i][j]表示在以i为根的子树中，用大小为j的包能取得的最大价值，
dp[i][j]=max(dp[left[i]][j-w[i]]+v[i],dp[right[i]][j])；
left[i]是i在原树中的第一个儿子，right[i]是i在原树中的下一个兄弟。
第二种方法：dfs序表示法：
我们对于每一个节点求出他在原树中的dfs序dfn值，然后记录他的子数大小size；
那么对于一个节点x：x的第一个儿子y有dfn[y]=dfn[x]+1；
对于x的第二个儿子z，dfn[z]=dfn[x]+size[y]+1;
对于x的一个兄弟k，有dfn[k]=dfc[x]+size[x]+1;
一个dfs序为i的节点u，同样设dp[i][j]表示在以u为根的子树中，用大小为j的包能取得的最大价值，
dp[i][j]+w[i]->dp[i+1][j-v[i]]
dp[i][j]->dp[i+size[i]+1][j]
这也是较常用的刷表法，用当前状态更新后继的状态；
两种方法主要解决点权问题；
那么我们看一下用树形分组背包问题：
一道经典问题 选课：题目传送门;
题解（https://www.cnblogs.com/Tyouchie/p/10830072.html）；
我们设dp[k][i][j]表示以i为根的子树，在前k个儿子中，选出一个大小为j的子树（必须包含i），所获得的最大学分。
那么我们每计算到第k+1个新的儿子v时(size[v]表示v的儿子个数)，
dp[k+1][i][j]=min(dp[k][i][j-t]+dp[size[v]][v][t]);
k这一维显然可以无用的；
那么我们改为f[i][j]表示在以i为根的子树内选择了j门课程所获得的最大学分；
dp[i][j]=max(dp[i][j-t]+dp[v][t]);
j=m-1->1(m指容积，-1是因为当前点占据了1的体积）；
t=1->j（在我那片题解中我倒序枚举了t，但是我发现两者都是正确的）；
这个模型感觉要理解并且掌握，因为很多树形背包类dp的状态都是这样转移的；
#include<bits/stdc++.h>
using namespace std;
int lin[1000],tot,n,m,x,f[400][400],s[400];
template<typename T>inline void read(T &x)
{
x=0;T f=1,ch=getchar();
while(!isdigit(ch)) {if(ch=='-') f=-1; ch=getchar();}
while(isdigit(ch)) {x=x*10+ch-'0'; ch=getchar();}
x*=f;
}
struct gg {
int y,next;
}a[2000];
inline void add(int x,int y) {
a[++tot].y=y;
a[tot].next=lin[x];
lin[x]=tot;
}
inline void dp(int x) {
f[x][0]=0;
for(int i=lin[x];i;i=a[i].next) {
int y=a[i].y;
dp(y);
for(int t=m;t>=0;--t) {
for(int j=0;j<=t;++j) {
if(t-j>=0) {
f[x][t]=max(f[x][t],f[x][t-j]+f[y][j]);
}
}
}
}
if(x!=0) {
for(int t=m;t>0;t--)
f[x][t]=f[x][t-1]+s[x];
}
}
int main() {
read(n);read(m);
for(int i=1;i<=n;i++) {
read(x);
add(x,i);
read(s[i]);
}
dp(0);
cout<<f[0][m]<<endl;
return 0;
}
f[i][j]表示以i为根的子树内分离一个大小为j的子树所需要的最少操作数；
j=p->1;
t=1->j;
和上一道题目很像；
显然f[x][1]为每个点x的度；
再转移的时候-2是因为u->v的边和v->u的边都已经在初始化的时候被减掉了，所以这时候要把他们连起来就得减去他们两个造成的贡献，也就是2.，思考一下，很好理解；
#include<bits/stdc++.h>
using namespace std;
template<typename T>inline void read(T &x) {
x=0;
T f=1,ch=getchar();
while (!isdigit(ch)) {if(ch=='-') f=-1; ch=getchar();}
while (isdigit(ch)) x=(x<<1)+(x<<3)+(ch^48), ch=getchar();
x*=f;
}
const int N=250;
struct gg {
int y,next,v;
}a[N<<1];
int n,p,tot,x,y,lin[N],du[250],dp[250][250];
inline void add(int x,int y) {
a[++tot].y=y;
a[tot].next=lin[x];
lin[x]=tot;
}
inline void dfs(int x,int fa) {
dp[x][1]=du[x];
for(int i=lin[x];i;i=a[i].next) {
int y=a[i].y;
if(y==fa) continue;
dfs(y,x);
for(int j=p;j>=1;j--) {
for(int t=1;t<=j;t++) {
dp[x][j]=min(dp[x][j],dp[x][j-t]+dp[y][t]-2);
}
}
}
}
int main() {
read(n); read(p);
for(int i=1;i<n;i++) {
read(x); read(y);
add(x,y);
add(y,x);
du[x]++; du[y]++;
}
memset(dp,0x3f,sizeof(dp));
dfs(1,0);
int ans=1<<30;
for(int i=1;i<=n;i++) {
ans=min(ans,dp[i][p]);
}
cout<<ans<<endl;
return 0;
}
真正理解前两到题目这道也就不难了；
我们设f[i][j]表示在以i为根的子树内，让j个人看所获得的最大收益；
那么对于每一个叶子节点x，f[x][1]就等于val[x]；
那么最后我们寻找一个最大的i满足f[1][i]>=0;
所以我们倒序扫描就行了；
状态转移是j，t的枚举和前两题是一样的；
根据当前背包容积转移；
#include<bits/stdc++.h>
using namespace std;
template<typename T>inline void read(T &x) {
x=0;
T f=1,ch=getchar();
while (!isdigit(ch)) {if(ch=='-') f=-1; ch=getchar();}
while (isdigit(ch)) x=(x<<1)+(x<<3)+(ch^48), ch=getchar();
x*=f;
}
int n,m,dp[3010][3010],val[3010],k,x,v,tot,lin[3010];
struct gg {
int y,next,v;
}a[1000100];
inline void add(int x,int y,int v) {
a[++tot].y=y;
a[tot].next=lin[x];
lin[x]=tot;
a[tot].v=v;
}
int dfs(int u)
{
if(u>n-m) {
dp[u][1]=val[u];
return 1;
}
int sum=0,s,t;
for(int i=lin[u];i;i=a[i].next) {
int y=a[i].y;
s=dfs(y);
sum+=s;
for(int j=sum;j>0;j--) {
for(int t=1;t<=j;t++) {
dp[u][j]=max(dp[u][j],dp[u][j-t]+dp[y][t]-a[i].v);
}
}
}
return sum;
}
int main() {
memset(dp,0xcf,sizeof(dp));
read(n); read(m);
for(int i=1;i<=n-m;i++) {
read(k);
for(int j=1;j<=k;j++) {
read(x); read(v);
add(i,x,v);
}
}
for(int i=n-m+1;i<=n;i++) read(val[i]);
for(int i=1;i<=n;i++) dp[i][0]=0;
dfs(1);
for(int i=m;i>=1;i--)
if(dp[1][i]>=0) {
printf("%d",i);
break;
}
return 0;
}