蓝桥杯每日一题------背包问题（四）

前言

前面讲的都是背包的基础问题，这一节我们进行背包问题的实战，题目来源于一位朋友的询问，其实在这之前很少有题目是我自己独立做的，我一般习惯于先看题解，验证了题解提供的代码是正确的后，再去研究题解，这就给我自己养成了一种依赖的习惯。我害怕自己去挑战没有答案的问题，朋友问的这道题来源于一个小众网站，因此没有题解，出于试一试的态度，我也算比较轻松的做出来了，让我十分有满足感，十分感谢他。但是他好久之前问我的一道题，我现在还没有回他（sorry）。话不多说看题目吧。

数的分解

题目描述
把 A 分解成 B 个各不相同的正整数之和，并且要求每个正整数都不包含数字
2和4，一共有多少种不同的分解方法？注意交换几个整数的顺序被视为同一种方法，例如 1000+1001+18 和 1001+1000+18被视为同一种。
输入描述
第一行包一个整数 T，表示测试数据的规模。接下来 T 行每行 2 个整数A,B。
输出描述
对每个输入输出一个整数表示答案。
输入数据
2
10 2
2019 3
输出数据
2
40785
评测用例规模与约定
对于所有评测用例，1≤T≤10，1≤A≤2500，1≤B≤10。
这道题目类似于蓝桥杯的一道真题，那道真题是分解数字2019，可以去看一下，数的分解。因为那个题目只分解一个数字，所以采用dfs甚至for循环枚举都可以过。但是这道题目是分解好几个数字，而且分解后数字的个数也不是固定的，如果用dfs会超时。
那么试着考虑一下动态规划，因为无法为它划分为区间，状压，期望，树形，所以只能是普通的dp，那就用普通的dp的思考顺序进行思考。
定义dp数组
第一步：缩小规模。 考虑分解成B个整数，那么我用B当作数据规模。
第二步：限制。 需要记录当前B个数字之和是多少。除了这一个限制还有什么限制呢？选出来的数字不能包含2或4，这一个限制好考虑，只需要在选择的时候检查一遍就可以了。还有呢？还有需要保证选择的方案不会重复，这种限制最常见的是用a 第三步：写出dp数组。 dp[i][j][k]表示当前选择了i个数字，所选数字之和为j且最后一个选择的数字是k时的？。这样要求啥？求方案数啊，一般求啥表示啥（也有特殊情况），所以‘？’表示的是方案数。
第四步：推状态转移方程。 dp[i][j][k]应该从哪里转移过来呢，必然是从前i-1个数字的状态转移，这个状态还应该考虑此时j和k的情况，当前可以选择的数字必然是比j小，比k大,假设当前选择的数字是p，则$k<p<j$。所以$dp[i][j][p]+=dp[i-1][j-p][k]$
综上状态转移方程如下
$dp[i][j][p]+=dp[i-1][j-p][k]$
考虑写代码了
第一步：确定好遍历顺序。 对于背包问题，一般第一个for遍历规模，第二个for遍历限制。但是我们的限制有两个，所以加上规模一共三层嵌套的for循环。
第二步：确定好转移位置。 对于当前可以选择的数字，只要比k大我都可以尝试在这一步选择，所以需要一个for循环遍历此时转移的数字。综上一共4层嵌套的for循环。那么代码如下

	int dp[][][] = new int[k+1][n+1][n+1];//n表示要分解的数字，k表示分解后的数字个数
	// TODO Auto-generated method stub
	for(int i = 1;i <= n;i++) dp[1][i][i] = 1;
	for(int i = 1;i <= k;i++) {//10 遍历规模
		for(int j = 1;j <= n;j++) {//2500 遍历限制 
			for(int q = 1;q <= j;q++) {//
				if(check(q)) continue;//检查是否包含了2或4
				for(int p = q+1;p <= j;p++) {
                     if(check(p)) continue;
					 dp[i][j][p] += dp[i-1][j-p][q]; 
				}
			}
		}
	}

可以算一下上述思路的时间复杂度是$O(k\ast n\ast n\ast n)=10\ast 2500\ast 2500\ast 2500>1e8$，会超时。那么在写上述思路的过程中你有没有发现一个问题。对于n范围内的数字我只有可能会选择一次，选择k个数字，并且数字之和恰好等于n，这像不像二维01背包问题？没错就是！按照刚刚所想重新思考dp数组。
定义dp数组
第一步：缩小规模。 对于n范围内的数字我只有可能会选择一次，小于n的所有数字都可以看作是一个物品，一共有n个物品。
第二步：限制。
限制1：选出来的数字不能包含2或4，这一个限制好考虑，只需要在选择的时候检查一遍就可以了，不需要新的维度。
限制2：选出来的数字个数不能超过B，需要一个维度来限制。
限制3：选出来的数字之和不能超过n，需要一个维度来限制。
第三步：写出dp数组。 dp[i][j][k]表示当前选择了i个数字，所选数字之和为k所选数字个数为j时的方案数。
第四步：推状态转移方程。 dp[i][j][k]应该从哪里转移过来呢，必然是从前i-1个数字的状态转移，如果第i个数字不选，则 dp[i][j][k]+= dp[i-1][j][k]，如果选择第i个数字，则 dp[i][j][k]+= dp[i-1][j-1][k-i]
综上状态转移方程如下
$if(k>i)$ $dp[i][j][p]=dp[i-1][j][k]+dp[i-1][j-1][k-i]$
$else$ $dp[i][j][p]=dp[i-1][j][k]$
考虑写代码了
第一步：确定好遍历顺序。 对于背包问题，一般第一个for遍历规模，第二个for遍历限制。但是我们的限制有两个，所以加上规模一共三层嵌套的for循环。
第二步：确定好转移位置。 当前第i个数字进行转移，所以不需要额外的for循环，代码如下

import java.util.Scanner;
import java.util.Set;
import java.util.TreeSet;
public class Main{
	static int n,k,ans=0;
	//检查是不是带有2 或 4
	static Boolean  check(int parm) {
		while(parm>0) {
			int t=parm%10;
			if(t==2 || t==4) return true;
			parm/=10;
		}
		return false;
	}
public static void main(String[] args) {
//	f();
	Scanner scanner = new Scanner(System.in);
	int t = scanner.nextInt();
	long dp[][][] = new long[2500+1][10+1][2500+1];//当前考虑的物品，当前选择的物品个数，当前选择的物品的重量，当前物品选还是没选
	while(t-- > 0) {
		n=scanner.nextInt();
		k = scanner.nextInt();
		int sum=0;
		//从2500个物品里，选10个物品，且价值恰好为n		
		dp[0][0][0]=1;
		for(int i = 1;i <= n;i++) {
			dp[i][1][i] = 1;	
			dp[i][0][0] = 1;
//			dp[1][0][0][0] = 1;
		}
		for(int i = 1;i <= n;i++) {//
			for(int j = 1;j <= k;j++) {//
				for(int q = 1;q <= n;q++) {//
					if(check(i)) {
						dp[i][j][q] = dp[i-1][j][q];
					}
					else {
						if(q >= i)
						    dp[i][j][q] = dp[i-1][j-1][q-i]+dp[i-1][j][q];
						else
							dp[i][j][q] = dp[i-1][j][q];
					}	
//					System.out.println(dp[i][j][q] + " " + i + " " + j + " " + q);
				}
			}
		}
      
		long ans = 0;
		ans = dp[n][k][n]; 
		System.out.println(ans);
	}
}
}

此时的时间复杂度是$O(B\ast A\ast A)=10\ast 2500\ast 2500=62500000<1e8$，貌似可以，但是别忘了还有T，所以时间复杂度应该是$O(B\ast A\ast A\ast T)=10\ast 2500\ast 2500\ast 10=62500000>1e8$，但是我们可以看到当n=2500，t=1时是不超时的，而对于其它的n<2500和k<=10，其实可以直接用dp[n][k][n]来表示，所以我们只需要预处理出n=2500和k=10的情况，然后针对其它样例直接输出就可以了。
超时的问题解决了，还有一个问题，不太常遇到的问题，空间超限，因为我们设的数组是三维的，空间大小将近1e9了。这里可以考虑用滚动dp来节省空间，滚动dp在背包问题（一）中进行过讲解，修改后的代码如下，

import java.util.Arrays;
import java.util.Scanner;
import java.util.Set;
import java.util.TreeSet;

public class Main{
	static int n,k,ans=0;
	//检查是不是带有2 或 4
	static Boolean  check(int parm) {
		while(parm>0) {
			int t=parm%10;
			if(t==2 || t==4) return true;
			parm/=10;
		}
		return false;
	}
public static void main(String[] args) {
//	f();
	Scanner scanner = new Scanner(System.in);
	int t = scanner.nextInt();
	long dp[][][] = new long[2][10+1][2500+1];//当前考虑的物品，当前选择的物品个数，当前选择的物品的重量，当前物品选还是没选
	dp[0][0][0] = 1;
	dp[1][1][1] = 1;
	dp[1][0][0] = 1;
	n = 2500;
	k = 10;
	for(int i = 1;i <= n;i++) {//
		for(int j = 1;j <= k;j++) {//
			for(int q = 1;q <= n;q++) {//                             
				if(check(i)) {
					dp[i&1][j][q] = dp[(i-1)&1][j][q];
				}
				else {
					if(q >= i)
					    dp[i&1][j][q] = dp[(i-1)&1][j-1][q-i]+dp[(i-1)&1][j][q];
					else
						dp[i&1][j][q] = dp[(i-1)&1][j][q];
				}	
//				System.out.println(dp[i][j][q] + " " + i + " " + j + " " + q);
			}
		}
	}
	while(t-- > 0) {
		n=scanner.nextInt();
		k = scanner.nextInt();
		long ans = 0;
		ans = dp[n&1][k][n]; 
		System.out.println(ans);
	}
}
}

这个网站的题目应该是对蓝桥杯题目进行了改编，不得不说改编的质量还是挺高的，再来另一个类似的题目

数的分解2

题目描述
将 N 拆分成 M 个正整数之和，总共有多少种拆分方法？注意交换顺序视为不同的方法，例如 2025 = 1000 + 1025 和 2025 = 1025 + 1000 就视为不同的方法。
输入描述
第一行包一个整数 T，表示测试数据的规模。接下来
T 行每行 2 个整数,N,M。
输出描述
对每个输入输出一个整数表示答案。由于答案可能会很大，请输出答案除以 109+7 的结果。
输入数据
2
40 5
1988 2
输出数据
82251
1987
评测用例规模与约定
对于所有评测用例，1≤T≤10，1≤N≤2500，1≤M≤10。
这道题和上一道题有什么区别呢？除了没有不能选包含2和4的数字的约数之外，还规定了不同的顺序视为不同的方案，这样就不是01背包了。因为对于01背包而言，10+11和11+10是一种方案。还是先按照dp的步骤考虑一下。
定义dp数组
第一步：缩小规模。 考虑分解成B个整数，那么我用B当作数据规模。
第二步：限制。 需要记录当前B个数字之和是多少。
第三步：写出dp数组。 dp[i][j]表示当前选择了i个数字，所选数字之和为j时的方案数。
第四步：推状态转移方程。 dp[i][j]应该从哪里转移过来呢，必然是从前i-1个数字的状态转移，这个状态还应该考虑此时j的情况，当前可以选择的数字必然是比j小,假设当前选择的数字是p，则$p<j$。所以$dp[i][j]+=dp[i-1][j-p]$
综上状态转移方程如下
$dp[i][j][p]+=dp[i-1][j-p]$
考虑写代码了
第一步：确定好遍历顺序。 对于背包问题，一般第一个for遍历规模，第二个for遍历限制。
第二步：确定好转移位置。 对于当前可以选择的数字，只要比j小我都可以尝试在这一步选择，所以需要一个for循环遍历此时转移的数字。综上一共3层嵌套的for循环。那么代码如下

import java.util.Arrays;
import java.util.Scanner;
import java.util.Set;
import java.util.TreeSet;

public class Main{
	static int n,k,ans=0;
public static void main(String[] args) {
	Scanner scanner = new Scanner(System.in);
	int t = scanner.nextInt();
	n = 2500;
	k = 10;
	int mod = (int) (1e9+7);
	int dp[][] = new int[k+1][n+1];
	// TODO Auto-generated method stub
	for(int i = 1;i <= n;i++) dp[1][i] = 1;
	for(int i = 1;i <= k;i++) {//10 遍历规模
		for(int j = 1;j <= n;j++) {//2500 遍历限制 
			for(int q = 1;q <= j;q++) {//
					 dp[i][j] += dp[i-1][j-q]; 
					 dp[i][j] %= mod;
			}
		}
	}
	while(t-- > 0) {
		n=scanner.nextInt();
		k = scanner.nextInt();
		long ans = 0;
		ans = dp[k][n]; 
		System.out.println(ans);
	}
}

该思路的时间复杂度是$O(N\ast M\ast N)=2500\ast 2500\ast 10<1e8$，可以通过本题。
可以看见同一个思路，因为限制的降低，dp数组维数降低，时间复杂度就降低了。