闫式DP分析法
参考视频： https://www.bilibili.com/video/BV1X741127ZM/?spm_id_from=333.788.videocard.0
分析思想
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8za2iVGq-1605705400227)(https://note.youdao.com/yws/api/personal/file/1208AC100C214D67A123AB26FB2ABB9B?method=download&shareKey=2fe85c9ad77c808886878f00a7b88dd4)]](https://img-blog.csdnimg.cn/20201118211726629.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NhbHRlZF9fX2Zpc2g=,size_16,color_FFFFFF,t_70#pic_center)
- DP问题一般是求若干有限集合中的最值问题，并且此类问题存在子问题重叠
（Overlap-subproblems），如果通过暴力枚举每种可能解决问题，那么将会有大量重复的计算；如果从集合角度来分析DP问题，每次枚举一个集合并且利用子问题重叠特性，将子问题的解存储下来，可以大大提高效率； - DP问题的核心是状态集合 f(i) 的定义，在状态及转移计算中，划分子集的依据：寻找最后一个不同点，即处理最后一个子集的选择。
背包问题
import java.util.ArrayList;
import java.util.Scanner;
/**
* 有 N 件物品和一个容量是 V 的背包。每件物品只能使用一次（完全背包可以使用任意次）。
*
* 第 i 件物品的体积是 vi，价值是 wi。
*
* 求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。
* 输出最大价值。
*
* 输入格式
* 第一行两个整数，N，V，用空格隔开，分别表示物品数量和背包容积。
*
* 接下来有 N 行，每行两个整数 vi,wi，用空格隔开，分别表示第 i 件物品的体积和价值。
*
* 输出格式
* 输出一个整数，表示最大价值。
*/
public class Knapsack{
// 1. 01背包问题的朴素解法
private static void simpleSolutionOf01() {
int N = 0;
int V = 0;
int[] v = new int[0];
int[] w = new int[0];
// 读取操作
try (
Scanner reader = new Scanner(System.in) // 读入数据的代码（基于正则表达式的文本扫描器）
) {
N = reader.nextInt(); // 物品的数量为N
V = reader.nextInt(); // 背包的容量为V
v = new int[N+1] ; // 一个长度为N的数组，第i个元素表示第i个物品的体积；
w = new int[N+1] ; // 一个长度为N的数组，第i个元素表示第i个物品的价值；
for (int i = 1 ; i <= N ; i++){
// 接下来有 N 行，每行有两个整数:v[i],w[i]，用空格隔开，分别表示第i件物品的体积和价值
v[i] = reader.nextInt();
w[i] = reader.nextInt();
}
} catch (Exception e) {
e.printStackTrace();
}
// 正式工作的代码
/*
定义状态集合为 f(i,j) 含义：在只能选择前 i 个物品，背包容量为 j 的情况下的所有方案的集合；
状态集合为 f(i,j) 属性：所有方案中价值最大的值；
具体实现为一个二阶矩阵f[N+1][V+1]，这里之所以要 N+1 和 V+1，
是因为第 0 行表示只能选择第 0 个物品的时候，即没有物品的时候，第 0 列表示背包的体积为 0 的时候，即不能装任何东西的时候；
f[i][j]表示在只能选择前 i 个物品，背包容量为 j 的情况下，背包中物品的最大价值，对于f[i][j]有两种情况：
1. 不选择当前的第i件物品/第i件物品比背包容量要大，则f[i][j] = f[i-1][j]
2. 选择当前的第i件物品（潜在要求第i件物品体积小于等于背包总容量），则能装入的物品最大价值为：
当前物品的价值 加上 背包剩余容量在只能选前 i-1 件物品的情况下的最大价值
f[i][j] = f[i-1][j-v[i]] + w[i]
f[i][j]在两种情况中选择比较大的情况作为当前的最优解，即：
if(j >= v[i]):
f[i][j] = max(f[i-1][j], f[i-1][j-v[i]] + w[i])
else:
f[i][j] = f[i-1][j]
*/
int[][] f = new int[N+1][V+1];
for(int i = 1; i <= N; i++){
for(int j = 0; j <= V; j++){
if(j >= v[i] ){
f[i][j] = Math.max(f[i-1][j], f[i-1][j-v[i]] + w[i]);
}else{
f[i][j] = f[i-1][j];
}
}
}
System.out.println(f[N][V]);
}
// 2. 01背包问题的空间优化解法
private static void spaceOptSolutionOf01() {
int N = 0;
int V = 0;
int[] v = new int[0];
int[] w = new int[0];
try (
Scanner reader = new Scanner(System.in) // 读入数据的代码（基于正则表达式的文本扫描器）
) {
N = reader.nextInt(); // 物品的数量为N
V = reader.nextInt(); // 背包的容量为V
v = new int[N+1] ; // 一个长度为N的数组，第i个元素表示第i个物品的体积；
w = new int[N+1] ; // 一个长度为N的数组，第i个元素表示第i个物品的价值；
for (int i = 1 ; i <= N ; i++){
// 接下来有 N 行，每行有两个整数:v[i],w[i]，用空格隔开，分别表示第i件物品的体积和价值
v[i] = reader.nextInt();
w[i] = reader.nextInt();
}
} catch (Exception e) {
e.printStackTrace();
}
// 正式工作的代码
/*
f[i][j] = max(f[i-1][j], f[i-1][j-v[i]] + w[i])，可以看出f[i][j]的值只跟前一行（i-1）的值有关，所以最少只需要一行数组存储即可；
而且 j 总是在前一行从后往前找(j or j-v[i])，即只需要旧的一行前面的值，即从后往前更新能保证前一行前面可能被用到的值不被修改；
所以省去第一维下标后：
f[j] = max(f[j], f[j-v[i]] + w[i])
*/
int[] f = new int[V+1];
for(int i = 1; i <= N; i++){
for(int j = V; j >= 0; j--){ // 这里改成从后往前
if(j >= v[i] ){
f[j] = Math.max(f[j], f[j-v[i]] + w[i]);
// }else{
// f[j] = f[j]; // 这两行也可以省略了
}
}
}
System.out.println(f[V]);
}
/*
完全背包问题：
无论是朴素的还是空间优化的完全背包问题 相比于 01背包问题都只需要改动一行代码，但其背后的思想有很大不同
*/
// 3. 完全背包问题的朴素解法
private static void simpleSolutionOfComplete() {
int N = 0;
int V = 0;
int[] v = new int[0];
int[] w = new int[0];
try (
Scanner reader = new Scanner(System.in) // 读入数据的代码（基于正则表达式的文本扫描器）
) {
N = reader.nextInt(); // 物品的数量为N
V = reader.nextInt(); // 背包的容量为V
v = new int[N+1] ; // 一个长度为N的数组，第i个元素表示第i个物品的体积；
w = new int[N+1] ; // 一个长度为N的数组，第i个元素表示第i个物品的价值；
for (int i = 1 ; i <= N ; i++){
// 接下来有 N 行，每行有两个整数:v[i],w[i]，用空格隔开，分别表示第i件物品的体积和价值
v[i] = reader.nextInt();
w[i] = reader.nextInt();
}
} catch (Exception e) {
e.printStackTrace();
}
// 正式工作的代码
/*
状态转移方程：
01背包： f[i][j] = max(f[i-1][j], f[i-1][j-v[i]] + w[i])
完全背包：f[i][j] = max(f[i-1][j], f[i][j-v[i]] + w[i])
完全背包状态转移方程推导：
在01背包中，f[i][j]只有两种情况，选0个 or 选1个，而在完全背包问题中，f[i][j]有很多种可能，选 0 or 1 or 2 or ... or k ... 直到超过容量，所以：
f[i][j] = max(f[i-1][j], f[i-1][j-v[i]] + w[i], f[i-1][j-2v[i]] + 2w[i], ... , f[i-1][j-kv[i]] + kw[i], ...) 一直到超过容量
用 j-v[i] 对 j 进行变量替换得：
f[i][j-v[i]] = max(f[i-1][j-v[i]], f[i-1][j-2v[i]] + w[i], f[i-1][j-2v[i]] + 2w[i], ... , f[i-1][j-(k+1)v[i]] + kw[i], ...)
所以：
f[i][j] = max(f[i-1][j], f[i][j-v[i]] + w[i])
*/
int[][] f = new int[N+1][V+1];
for(int i = 1; i <= N; i++){
for(int j = 0; j <= V; j++) {
if (j >= v[i])
f[i][j] = Math.max(f[i-1][j], f[i][j-v[i]] + w[i]); // 相比于 朴素的01背包解法只需要改动这里的状态转移方程
else
f[i][j] = f[i-1][j];
}
}
System.out.println(f[N][V]);
}
// 4. 完全背包问题的空间优化解法
private static void spaceOptOfComplete() {
int N = 0;
int V = 0;
int[] v = new int[0];
int[] w = new int[0];
try (
Scanner reader = new Scanner(System.in) // 读入数据的代码（基于正则表达式的文本扫描器）
) {
N = reader.nextInt(); // 物品的数量为N
V = reader.nextInt(); // 背包的容量为V
v = new int[N+1] ; // 一个长度为N的数组，第i个元素表示第i个物品的体积；
w = new int[N+1] ; // 一个长度为N的数组，第i个元素表示第i个物品的价值；
for (int i = 1 ; i <= N ; i++){
// 接下来有 N 行，每行有两个整数:v[i],w[i]，用空格隔开，分别表示第i件物品的体积和价值
v[i] = reader.nextInt();
w[i] = reader.nextInt();
}
} catch (Exception e) {
e.printStackTrace();
}
// 正式工作的代码
/*
01背包： f[i][j] = max(f[i-1][j], f[i-1][j-v[i]] + w[i])
完全背包：f[i][j] = max(f[i-1][j], f[i][j-v[i]] + w[i])
看上式可以看出两个状态转移方程只有一个地方不同 —— f[i-1][j-v[i]] 和 f[i][j-v[i]]；
在01背包中， j 必须从大到小，是因为 f[i-1][j-v[i]] 会用到更新前(i-1)行前面的值，为了不修改它，所以要从后往前更新
而在完全背包中，j 必须从小到大，是因为 f[i][j-v[i]] 会用到更新后( i )行前面的值，为了及时更新它，所以要从前往后更新
所以省去第一维下标后（跟01相同）：
f[j] = max(f[j], f[j-v[i]] + w[i])
*/
int[] f = new int[V+1];
for(int i = 1; i <= N; i++){
for(int j = 0; j <= V; j++) // 只需要把这里改成从小到大
if(j >= v[i] )
f[j] = Math.max(f[j], f[j-v[i]] + w[i]); // 虽然这里跟 01 完全一样，但它们背后的含义是不同的，省去的下标不完全相同
}
// 等价于:
/*
for(int i = 1; i <= N; i++){
for(int j = v[i]; j <= V; j++)
f[j] = Math.max(f[j], f[j-v[i]] + w[i]);
}
*/
System.out.println(f[V]);
}
// 5. 多重背包问题的空间优化解法
private static void spaceOptOfMultiple() {
int N = 0;
int V = 0;
int[] v = new int[0];
int[] w = new int[0];
int[] s = new int[0];
try (
Scanner reader = new Scanner(System.in) // 读入数据的代码（基于正则表达式的文本扫描器）
) {
N = reader.nextInt(); // 物品的数量为N
V = reader.nextInt(); // 背包的容量为V
v = new int[N+1] ; // 一个长度为N的数组，第i个元素表示第i个物品的体积；
w = new int[N+1] ; // 一个长度为N的数组，第i个元素表示第i个物品的价值；
s = new int[N+1] ; // 一个长度为N的数组，第i个元素表示第i个物品的数量；
for (int i = 1 ; i <= N ; i++){
// 接下来有 N 行，每行有三个整数:v[i],w[i],s[i]，用空格隔开，分别表示第i件物品的体积、价值和数量
v[i] = reader.nextInt();
w[i] = reader.nextInt();
s[i] = reader.nextInt();
}
} catch (Exception e) {
e.printStackTrace();
}
// 正式工作的代码
/*
01背包： f[i][j] = max(f[i-1][j], f[i-1][j-v[i]] + w[i])
完全背包：f[i][j] = max(f[i-1][j], f[i][j-v[i]] + w[i])
多重背包：
在01背包问题中只有两种选择，选0 or 选1，所以状态转移方程为：
f[i][j] = max(f[i-1][j], f[i-1][j-v[i]] + w[i])，
而在多重背包中，存在多重可能，一个最简单的思路就是在01的基础上拓展，选0 or 选1 or 选2 ... 选k，所以状态转移方程为：
f[i][j] = max(f[i-1][j], f[i-1][j-v[i]] + w[i], f[i-1][j-2v[i]] + 2w[i] ,..., f[i-1][j-kv[i]] + kw[i])，
所以只需要在 01背包 的基础上加个 0-k 的循环即可。
省去第一维下标后：
f[j] = max(f[j], f[j-v[i]] + w[i], f[j-2v[i]] + 2w[i] ,..., f[j-kv[i]] + kw[i])
*/
int[] f = new int[V+1];
for(int i = 1; i <= N; i++){ // 第 i 个物品
for(int j = V; j >= 0; j--) { // 从后往前
for (int k = 0; k <= s[i]; k++)
if (j >= k*v[i])
f[j] = Math.max(f[j], f[j-k*v[i]] + k*w[i]);
}
}
System.out.println(f[V]);
}
// 6. 多重背包问题的二进制优化解法
private static void binaryOptOfMultiple() {
int N = 0;
int V = 0;
int[] w = new int[0];
int[] v = new int[0];
int[] s = new int[0]; // 一个长度为N的数组，第i个元素表示第i个物品的数量；
try (
Scanner reader = new Scanner(System.in) // 读入数据的代码（基于正则表达式的文本扫描器）
) {
N = reader.nextInt(); // 物品的数量为N
V = reader.nextInt(); // 背包的容量为V
w = new int[N+1] ;
v = new int[N+1] ;
s = new int[N+1] ;
for (int i = 1 ; i <= N ; i++){
// 接下来有 N 行，每行有三个整数:v[i],w[i],s[i]，用空格隔开，分别表示第i件物品的体积、价值和数量
v[i] = reader.nextInt();
w[i] = reader.nextInt();
s[i] = reader.nextInt();
}
} catch (Exception e) {
e.printStackTrace();
}
// 正式工作的代码
/*
思路：将多重背包问题拆分为 01背包问题，但不是一个一个拆分，但又能够达到同样的组合效果
二进制拆分：例如 7 = 2^0 + 2^1 + 2^2, 其中1，2，4可以组合成1-7中的任何数字，这跟一个一个拆分的效果是一样的；
如果拆分的不恰好是2^n-1，例10 = 2^0 + 2^1 + 2^2 + 3，其中1，2，4，3 恰好可以组合成1-10中的任何数字，而且不会越界
*/
ArrayList<Integer> nw = new ArrayList<>();
ArrayList<Integer> nv = new ArrayList<>();
nw.add(0,0); // 首位不存值
nv.add(0,0);
// 拆分并添加到数组
for (int i = 1; i <= N; i++) {
for (int k = 1; k <= s[i]; k *= 2) {
s[i] -= k; // k 拆分的份数
nw.add(k * w[i]); // 添加重量
nv.add(k * v[i]); // 添加体积
}
if (s[i] > 0) {
nw.add(s[i] * w[i]); // 添加重量
nv.add(s[i] * v[i]); // 添加体积
}
}
// 01 背包的解法
int[] f = new int[V+1];
for(int i = 1; i < nw.size(); i++){ // 第 i 个物品
for(int j = V; j >= nv.get(i); j--) { // 从后往前
f[j] = Math.max(f[j], f[j-nv.get(i)] + nw.get(i));
}
}
System.out.println(f[V]);
}
public static void main(String[] args){
// simpleSolutionOf01();
// spaceOptSolutionOf01();
// simpleSolutionOfComplete();
// spaceOptOfComplete();
// spaceOptOfMultiple();
binaryOptOfMultiple();
}
}
/*
Input:
20 200
24 50
42 60
20 49
7 15
48 115
4 11
3 8
7 5
52 66
50 25
5 8
9 25
14 40
9 22
55 42
40 30
35 49
33 16
12 12
65 127
Output:
454 -- 01
571 -- complete
Input:
4 5
1 2 3
2 4 1
3 4 3
4 5 2
Output
10 -- multiple
*/
石子合并问题
import java.util.Scanner;
/**
* 设有N堆石子排成一排，其编号为1，2，3，…，N。
*
* 每堆石子有一定的质量，可以用一个整数来描述，现在要将这N堆石子合并成为一堆。
*
* 每次只能合并相邻的两堆，合并的代价为这两堆石子的质量之和，合并后与这两堆石子相邻的石子将和新堆相邻，合并时由于选择的顺序不同，合并的总代价也不相同。
*
* 例如有4堆石子分别为 1 3 5 2， 我们可以先合并1、2堆，代价为4，得到4 5 2， 又合并 1，2堆，代价为9，得到9 2 ，再合并得到11，总代价为4+9+11=24；
*
* 如果第二步是先合并2，3堆，则代价为7，得到4 7，最后一次合并代价为11，总代价为4+7+11=22。
*
* 问题是：找出一种合理的方法，使总的代价最小，输出最小代价。
*
* 输入格式
* 第一行一个数N表示石子的堆数N。
*
* 第二行N个数，表示每堆石子的质量(均不超过1000)。
*
* 输出格式
* 输出一个整数，表示最小代价
*
* Input:
* 4
* 1 3 5 2
*
* Output:
* 22
*/
public class StonesCombined {
public static void main(String[] args) {
// 读入
int N = 0;
int[] sumN = new int[0];
try (
Scanner reader = new Scanner(System.in);
) {
N = reader.nextInt();
sumN = new int[N+1]; // 前 n 项和
// 这里直接处理成前 n 项之和
for (int i = 1; i <= N; i++) {
sumN[i] = sumN[i-1] + reader.nextInt();
}
} catch(Exception e) {
e.printStackTrace();
}
// 正式工作的代码
/*
状态集为 f(i,j) 含义：所有将区间 [i,j] 合并成一个堆的方案的集合；
状态集为 f(i,j) 属性：值代表这些方案集合中最小的代价；
状态转移方程：将区间 [i,j] 分成相邻两部分共有 j-i 种分法，
分别对应 [i,i]&[i+1,j], [i,i+1]&[i+2,j], [i,i+2]&[i+3,j], ... ,[i,k]&[k+1,j], ... ,[i,j-1]&[j,j]；
其中每个子区间 [i,k]、[k+1,j] 合并成一个堆的方案的集合为 f(i,k) 、f(k+1,j)；
所以f(i,j) = k from i to j-1_min{f(i,k) + f(k+1,j)} + (w[i]+w[i+1]+...+w[j])；
即：f(i,j) = k from i to j-1_min{f(i,k) + f(k+1,j)} + (sumN[j] - sumN[i-1])；
*/
int[][] f = new int[N+1][N+1];
for (int len = 2; len <= N; len++) { // 枚举区间长度，长度为 1 时不用合并，代价为 0 忽略，从 2 开始
for (int i = 1; i + len -1 <= N; i++) { // 枚举区间左端点，（i+len-1）为右端点
int j = i + len -1; // 右端点
f[i][j] = Integer.MAX_VALUE; // 不要忘了先给个很大的值，如果是求最大值就给个很小的值，当然默认为 0
for (int k = i; k < j; k++) { // 更新 f[i][j]
f[i][j] = Math.min(f[i][j], f[i][k] + f[k+1][j] + sumN[j]-sumN[i-1]);
}
}
}
System.out.println(f[1][N]); // 根据状态集定义，左端点为 1，右端点为 N时的最小值，即全局最小值
}
}
最长公共子序列
import java.util.Scanner;
/**
* 给定两个长度分别为N和M的字符串A和B，求既是A的子序列又是B的子序列的字符串长度最长是多少。
* 一个字符串的 子序列 是指这样一个新的字符串：它是由原字符串在不改变字符的相对顺序的情况下删除某些字符（也可以不删除任何字符）后组成的新字符串。
* 例如，"ace" 是 "abcde" 的子序列，但 "aec" 不是 "abcde" 的子序列。两个字符串的「公共子序列」是这两个字符串所共同拥有的子序列。
*
* 若这两个字符串没有公共子序列，则返回 0。
*
* 输入格式
* 第一行包含两个整数N和M。
*
* 第二行包含一个长度为N的字符串，表示字符串A。
*
* 第三行包含一个长度为M的字符串，表示字符串B。
*
* 字符串均由小写字母构成。
*
* 输出格式
* 输出一个整数，表示最大长度。
*
* Input:
* 4 5
* acbd
* abedc
*
* Output:
* 3
* 解释：a bd, ab d
*/
public class LongestCommonSubsequence {
public static void main(String[] args) {
// 读入
int N = 0;
int M = 0;
char[] A = new char[0];
char[] B = new char[0];
try (
Scanner reader = new Scanner(System.in);
) {
N = reader.nextInt();
M = reader.nextInt();
A = new char[N+1];
B = new char[M+1];
String a = reader.next();
String b = reader.next();
for (int i = 1; i <= N; i++)
A[i] = a.charAt(i-1);
for (int i = 1; i <= M; i++)
B[i] = b.charAt(i-1);
} catch(Exception e) {
e.printStackTrace();
}
// 正式工作代码
/*
状态表示：
对于一个长度为 N 的序列，一共有 2^N 个子序列（每个 在 or 不在）；
定义状态集合 f(i,j) 含义：所有在字符串区间 A[1~i] 与 A[1-j] 的公共子序列的集合；
定义状态集合 f(i,j) 属性：其中最长的子序列的长度；
状态计算：
f(i,j) 可分为四种（可重复，不可遗漏）：
00 不含A[i]且不含B[j] = f(i-1,j-1);
01 不含A[i]且含B[j] = f(i-1,j); (存在重复，但不影响最大值)
10 含A[i]且不含B[j] = f(i,j-1); (存在重复，但不影响最大值)
11 含A[i]且含B[j]，此时A[i]一定等于B[j] = f(i-1,j-1)+1;
所以 f(i,j) = max{ f(i-1,j-1), f(i-1,j), f(i,j-1), if A[j]==B[j] --> f(i-1,j-1)+1 }
*/
int[][] f = new int[N+1][M+1];
for (int i = 1; i <= N; i++)
for (int j = 1; j <=M; j++) {
f[i][j] = Math.max(f[i-1][j], f[i][j-1]);
if (A[i] == B[j])
f[i][j] = Math.max(f[i][j], f[i-1][j-1]+1);
}
System.out.println(f[N][M]); // 根据状态集合定义
}
}
887
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
