今日总结2024/5/19

今日学习了简单树形dp，记忆化搜索

P2014 [CTSC1997] 选课

在大学里每个学生，为了达到一定的学分，必须从很多课程里选择一些课程来学习，在课程里有些课程必须在某些课程之前学习，如高等数学总是在其它课程之前学习。现在有 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

思路：若考虑每门课都有先修课，每门先修课都是一个入度为0的点，分开计算较困难，可以把这些先修课用一个前驱结点连起来作为根结点的孩子，这样可以作为树型结构来进行选择

有因为有选课数量上限，每门课有选和不选，且要求最大获得学分，因此有点像背包问题

可以联想到树形分组背包,f[i,j]表示以i为根结点，选课数不超过j的最大价值

因此要预处理好子结点的最大价值来递推,且增加一个结点要枚举m+1次

将每个子树看成物品组来选,每门课体积为1，然后枚举每个子树的体积来优化即可

#include <iostream>
#include <algorithm>
#include <cstring>
using namespace std;
const int N=310;
int h[N],ne[N],e[N],idx,f[N][N];//以i为根结点，选课数不超过j获得的最大学分
int n,m,w[N];//学分

void add(int a,int b){
	ne[idx]=h[a];
	e[idx]=b;
	h[a]=idx++;
}

void dfs(int u){
	for(int i=1;i<=m;i++) f[u][i]=w[u];//以u为根结点,u必选,加上权值
	for(int i=h[u];i!=-1;i=ne[i]) dfs(e[i]);//递归处理子结点
	
	for(int i=h[u];i!=-1;i=ne[i]){//循环物品组
		int son=e[i];
		for(int j=m;j>=1;j--)//j一定要能选一门才能保证选上根结点
		for(int k=0;k<=j-1;k++)
		f[u][j]=max(f[u][j],f[u][j-k]+f[son][k]);//加上的是子树在k体积下所选的最大价值f[son][k]!!!
	}
}

int main(){
	cin>>n>>m;
	m++;//多了一个0为根结点
	memset(h,-1,sizeof h);
	for(int i=1;i<=n;i++){
		int k,s;cin>>k>>w[i];
		add(k,i);//先修课到课i有边
	}
	dfs(0);//从根结点开始
	cout<<f[0][m];
	return 0;
}

 Acwing.10 有依赖的背包问题

同上，多了根结点判断和每个物品的体积也就是代价不再是1

#include <iostream>
#include <algorithm>
#include <cstring>
using namespace std;
int n,m;
const int N=110;
int v[N],w[N];
int h[N],ne[N],e[N],idx,f[N][N];//以i为根结点,体积不超过j的最大价值

void add(int a,int b){
    ne[idx]=h[a];
    e[idx]=b;
    h[a]=idx++;
}

void dfs(int u){//当前到第几个结点
    for(int i=v[u];i<=m;i++) f[u][i]=w[u];//因为体积大于等于当前根结点的方案都是必选v[u]的，初始化价值
    for(int i=h[u];i!=-1;i=ne[i]) dfs(e[i]);//递归处理好子结点
    
    for(int i=h[u];i!=-1;i=ne[i]){//循环物品组,也就是子树
        int son=e[i];
        for(int j=m;j>=v[u];j--)//循环体积
        for(int k=0;k<=j-v[u];k++)//循环子树的体积
        f[u][j]=max(f[u][j],f[u][j-k]+f[son][k]);
    }
}

int main(){
    memset(h,-1,sizeof h);
    cin>>n>>m;
    int root;
    for(int i=1;i<=n;i++){
        int fa;//存父结点
        cin>>v[i]>>w[i]>>fa;
        if(fa==-1) root=i;
        else add(fa,i);//父节点到i点有边
    }
    dfs(root);
    
    cout<<f[root][m];
    return 0;
}

P1434 [SHOI2002] 滑雪 

1   2   3   4   5
16  17  18  19  6
15  24  25  20  7
14  23  22  21  8
13  12  11  10  9

从里面每个点走，且要保持降序，求最大下降序列长度，首先想到暴力搜索每个点开始往下走，但是每次用到比自己小的下一个点的最大长度+1来更新，因此每次会重复搜索一些值，可以把它记录下来，避免重复搜索,保证单调下降就是保证这个搜索路径没有回路，避免死循环

#include <iostream>
#include <algorithm>
#include <cstring>
using namespace std;
const int N=105;
int r,c;
int h[N][N],f[N][N];//从i,j这个点开始走的最大长度
int dx[4]={0,-1,0,1},dy[4]={1,0,-1,0};

int dp(int i,int j){
	int &v=f[i][j];
	if(v!=-1) return v;//已经被记录
	v=1;
	for(int k=0;k<4;k++){
		int a=i+dx[k],b=j+dy[k];
		if(a>=1&&a<=r&&b>=1&&b<=c&&h[i][j]>h[a][b])
		v=max(v,dp(a,b)+1);
	}
	return v;//返回更新的记录
}

int main(){
	cin>>r>>c;
	for(int i=1;i<=r;i++)
	for(int j=1;j<=c;j++)
	cin>>h[i][j];
	
	memset(f,-1,sizeof f);
	int res=0;
	
	for(int i=1;i<=r;i++)
	for(int j=1;j<=c;j++)
	res=max(res,dp(i,j));
	
	cout<<res;
	return 0;
}