【No.16】蓝桥杯动态规划下|线性DP装箱问题|计数DP0/1背包的方案数|过河卒|完全背包小明的背包2|最长公共子序列|蓝桥骑士|推荐练习题(C++)

线性DP，0/1背包简化版，装箱问题

【题目描述】有一个箱子容量为V(正整数，$0\le V\le 20000$)，同时有n个物品($0<n\le 30$)，每个物品有一个体积(正整数)。要求 n 个物品中，任取若干个装入箱内，使箱子的剩余空间为最小。
【输入描述】输入第一行，一个整数，表示箱子容量。
第二行，一个整数n，表示有n个物品。
接下来n行，分别表示这n个物品的各自体积。
【输出描述】输出一行，表示箱子剩余空间。
0/1背包的简化版，不管物品的价格。把体积(不是价格)看成最优化目标:最大化体积。

#include<bits/stdc++.h>
using namespace std;
int dp[20010];
int w[40];
int main()
{
	int V,n;
	scanf("%d%d" ,&V,&n);
	for(int i = 1; i <= n; i ++)
		scanf("%d",&w[i]);
	for(int i = 1; i <= n; i ++)
		for(int j = V; j >= w[i]; j --)
			dp[j] = max(dp[j], dp[j-w[i]]+w[i])
	printf("%d\n", V-dp[V]);
	return 0;
}

计数DP，0/1背包的方案数

【题目描述】
将2022拆分成10个互不相同的正整数之和，总共有多少种拆分方法?
注意交换顺序视为同一种方法。
例如:
2022 = 1000+1022
2022 =1022+1000
视为同一种方法。

题目求10个数的组合情况，这十个数相加等于2022。因为是填空题可以不管运行时间，看起来可以用暴力for循环10次，加上剪枝。
然而暴力的时间极长，因为答案是:379187662194355221

这一题其实是0/1背包：
背包容量为2022，物品体积为1~2022，往背包中装10个物品，要求总体积为2022，问一共有多少种方案。

定义dp[][][]: dp[i][j][k]表示数字1~i取j个，和为k的方案数。下面的分析沿用标准0/1背包的分析方法，
从i-1扩展到i，分两种情况:

1. $k\ge i$。数i可以要，也可以不要
   1. 要i。从1~i-1中取j-1个数，再取i，等价于dp[i-1][j-1][k-i]。
   2. 不要i。从1~i-1中取j个数，等价于dp[i-1][j][k]
   3. 合起来:dp[i][j][k]= dp[i-1][j][k]+ dp[i-1][j-1][K-i]
2. k < i.
   由于数i比总和k还术、显然i不能用。
   有:dp[i][j][k]= dp[i-1][j][k]

for (int i = 0; i <= 2022; i ++)
	dp[i][0][0] = 1;   //特别注意这个初始化

1~i个数，选0个和为0的情况只有一种，就是不选

(1)k≥i。dp[i][j][k]= dp[i-1][j][k]+ dp[i-1][j-1][k-i]
(2)k<i。dp[i][j][k]= dp[i-1][j][k]

不用滚动数组

#include <bits/stdc++.h>
using namespace std;
long long dp[2222][11][2222]={0};
int main()
{
	for(int i = 0; i <= 2022; i ++)
		dp[i][0][0] = 1;    //特别注意这个初始化
	for(int i = 1; i <= 2022; i ++)
		for(int j = 1; j <= 10; j ++)  //注意:j从小到大，或从大到小都行
			for(int k = 1; k <= 2022; k ++)
			{
				if(k<i)
					dp[i][j][k] = dp[i-1][j][k]; //无法装进背包
				else
					dp[i][j][k] = dp[i-1][j][k] + dp[i-1][j-1][k-i];
	cout << dp[2022][10][2022];
	return 0;
}

使用滚动数组

#include <bits/stdc++.h>
using namespace std;
long long dp[11][2222];
int main()
{
	dp[0][0]=1;
	for(int i = 1; i <= 2022; i ++)
		for(int j = 10; j >= 1; j --) //j一定要从大到小
			for(int k = i; k <= 2022; k ++)
				dp[j][k] += dp[j-1][k-i];
	cout << dp[10][2022];
	return 0;
}

网格上的DP，过河卒

【题目描述】
棋盘上A点有一个过河卒，需要走到目标B点。
卒行走的规则:可以向下、或者向右。同时在棋盘上C点有一个对方的马，该马所在的点和所有跳跃一步可达的点称为对方马的控制点。因此称之为“马拦过河卒”。
现在要求你计算出卒从 A点能够到达B点的路径的条数，假设马的位置是固定不动的，并不是卒走一步马走一步。棋盘用坐标表示，A点(0，0)、B点(n，m)，同样马的位置坐标是需要给出的。1≤n,m≤20，0≤马的坐标≤20。【输入格式】
一行四个正整数，表示B点坐标和马的坐标。
【输出格式】
一个整数，表示所有的路径条数。

统计路径条数，看起来是个搜索题，可以用DFS求解。把马的控制点标记为不能走，绕过它们。
不过，用DFS搜索的路径数量是天文数字，肯定超时
在小学上过奥数的都知道，这题应该用“标数法”，就是在每个坐标点上记录能走的路径条数。
标数法实际上就是DP的递推。

定义状态dp[][]:
dp[i][j]表示卒走到坐标(i，j)时能走的路径条数。
如果不考虑马的控制点，有:dp[i][j]= dp[i-1][j]+ dp[i][j - 1]
也就是(i，j)点的路径条数等于它上面和左边的路径条数之和。这就是小学奥数的“标数法”的原理
本题的限制条件是马的控制点，只要令控制点的dp[i][j] = 0即可，即这个点上无路径

#include <bits/stdc++.h>
using namespace std;
long long dp[25][25];
bool s[25][25];  //标记马的9个控制点
int main()
{
	int bx，by,mx,my;
	scanf("%d%d%d%d",&bx，&by，&mx，&my);
	bx += 2;
	by += 2;
	mx += 2;
	my += 2;
	//技巧:坐标点加2，防止越界，因为马能向上向左跳2格
	dp[2][1] = 1;  	//初始化
	s[mx][my] = 1;	//标记马的控制点
	s[mx - 2][my + 1] = 1;
	s[mx - 2][my - 1] = 1;
	S[mx + 2][my - 1] = 1;
	s[mx + 2][my + 1] = 1;
	s[mx - 1][my - 2] = 1;
	s[mx - 1][my + 2] = 1;
	s[mx + 1][my + 2] = 1;
	s[mx + 1][my - 2] = 1;
	for(int i = 2; i <= bx; i ++)
		for(int j = 2; j <= by; j ++)
		{
			if(s[i][j])
				dp[i][j] = 0;  //这个点是控制点，不能走
			else
				dp[i][j] = dp[i-1][j] + dp[i][j - 1];