动态规划一般可分为线性动规，区域动规，树形动规，背包动规四类。动态规划程序设计是对解最优化问题的一种途径、一种方法，而不是一种特殊算法.不像搜索或数值计算那样，具有一个标准的数学表达式和明确清晰的解题方法。动态规划程序设计往往是针对一种最优化问题，由于各种问题的性质不同，确定最优解的条件也互不相同，因而动态规划的设计方法对不同的问题，有各具特色的解题方法，而不存在一种万能的动态规划算法，可以解决各类最优化问题。
对于背包动规，其常见的经典问题有：01背包问题，完全背包问题，分组背包问题，二维背包等。下文我们将依次对这些经典的问题作详细的分析，如有错误还请批评指正。
01背包问题
有 N 件物品和一个容量是 V的背包。每件物品只能使用一次。第 i件物品的体积是 vi，价值是 wi。求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。输出最大价值。
输入格式
第一行两个整数，N，V，用空格隔开，分别表示物品数量和背包容积。接下来有 N行，每行两个整数 vi,wi，用空格隔开，分别表示第 i件物品的体积和价值。
输出格式
输出一个整数，表示最大价值。
数据范围
0<N,V≤1000
0<vi,wi≤1000
输入样例
4 5
1 2
2 4
3 4
4 5
输出样例：
8
分析解答：
注意题目的关键信息----“每件物品只能使用一次”。我们不妨设当取第n件物品,背包的容量为v时,其最大价值用函数B(n,v)来表示.那我们又该如何来计算B(n,v)的值呢？我们只需依次从n往前进行递归判断即可.那么又该如何进行判断呢？
我们分为以下两个步骤:
(1)判断第n件商品得容量是否大于背包的容量，如果第n件商品的容量大于背包的容量,说明我们无法将第n件商品加入背包,即说明"当取第n件物品,背包的容量为v时,其最大价值B(n,v)"的值等于"取第n-1件物品,背包的容量为v时,其最大价值B(n-1,v)"的值.用状态转移方程式表示为B(n,v) = B(n-1,v).如果第n件商品得容量小于背包的容量，进入下一步.
(2)由于第n件商品的容量小于此时背包的容量.那我们就有两种选择，一是选择将当前商品加入背包，二是选着将商品不加入背包.当我们选着将商品加入背包时，此时商品的价值应该为上一状态的价值加上当前加入商品的价值w[n]，由于加入了商品所以背包的容量也会随之减少space[n].用状态转移方程式表示为B(n,v)=B(n-1,v-space[k]) + w[n].当我们选择不将该商品加入背包时,背包的容量不变，由于没有加入商品，此时背包的价值没有增加还是和上一个状态的背包的价值相等，用状态转移方程式表示为B(n,v) = B(n-1,v).
结合上图我们可以看出若要求得B(n,v)的值，那么一定会求B(n-1,v)，要求B(n-1,v)，又要求B(n-2,v)…直到n的值为0，找到递归出口…类似于下图的二维数组，其中横坐标表示背包的容量，纵坐标表示商品的数量
由表示可知,递归出口为,当没有商品时或者当背包的容量为0时递归结束.以下为该题的实现代码之一.
import java.util.Scanner;
public class Main{
static int[][] B = new int[1001][1001]; //创建一个查询数组
static int[] w = new int[1001]; //1 - n用来存放商品的价格
static int[] c = new int[1001]; //1 - n用来存放商品的空间
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
int n = sc.nextInt(); //物品数量
int v = sc.nextInt(); //背包容量
for(int i=1;i<=n;i++){
c[i] = sc.nextInt(); //第i件商品的体积
w[i] = sc.nextInt(); //第i件商品的价值
}
sc.close();
for(int k=1;k<=n;k++){
for(int space=1;space<=v;space++) {
if(c[k] > space){
B[k][space] = B[k-1][space];
} else {
int value1 = B[k-1][space-c[k]] + w[k];
int value2 = B[k-1][space];
if(value1 > value2){
B[k][space] = value1;
} else {
B[k][space] = value2;
}
}
}
}
System.out.println(B[n][v]);
}
}
空间复杂度优化
根据以上的状态转移方程我们不难发现,要求B(n,v)，就一定会涉及到上一个状态的值，并且也只与上一个状态的值有关，这便是动态规划里的后无效性原则. 由此我们可以对其进行进一步优化,我们可以只使用一维数组B[v+1]去记录上一个状态下的背包价值.
状态转移方程的变化图
由此我们可以进一步对代码进行优化
import java.util.Scanner;
public class Main {
static int[][] B = new int[1001][1001]; //创建一个查询数组
static int[] w = new int[1001]; //1 - n用来存放商品的价格
static int[] c = new int[1001]; //1 - n用来存放商品的空间
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt(); //表示一共有n种商品
int v = sc.nextInt(); //表示背包的总容量
for(int i=1;i<=n;i++) {
c[i] = sc.nextInt();
w[i] = sc.nextInt();
}
sc.close();
for(int i=1;i<=n;i++) {
for(int space=v;space>=1;space--) { //注意space这里一定要后往前递归,防止数据被覆盖
if(space>=c[i]) {
B[space] = Math.max(B[space],B[space-c[i]] + w[i]);
}
}
}
System.out.println(B[v]);
}
}
完全背包问题
有 N 种物品和一个容量是 V 的背包，每种物品都有无限件可用。第i种物品的体积是 vi，价值是 wi.求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。输出最大价值。
输入格式
第一行两个整数，N，V，用空格隔开，分别表示物品种数和背包容积。接下来有 N 行，每行两个整数 vi,wi，用空格隔开，分别表示第 i 种物品的体积和价值。
输出格式
输出一个整数，表示最大价值。
数据范围
0<N,V≤1000
0<vi,wi≤1000
输入样例
4 5
1 2
2 4
3 4
4 5
输出样例：
10
分析解答：
相比于"01背包问题"，完全背包问题最大的区别在于"每种物品都有无限件可用".那当我们取第n件物品是我们的选择就不在只有0和1两种方式(即选或者不选),而是可以选0,1,2,3,4…j件,jc[n] <= space;用状态转移方程式表示为 B[k] = max{B[k],B[k-jc[k]]+j*w[k]}.
import java.util.Scanner;
/*
完全背包问题
*/
public class Main {
static int[] B = new int[1001]; //创建一个查询数组
static int[] w = new int[1001]; //1 - n用来存放商品的价格
static int[] c = new int[1001]; //1 - n用来存放商品的空间
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt(); //表示商品的种类
int v = sc.nextInt(); //表示背包的容量
for(int i=1;i<=n;i++) { //录入数据
c[i] = sc.nextInt();
w[i] = sc.nextInt();
}
sc.close();
for(int k=1;k<=n;k++) {
for(int space=v;space>=1;space--) {
for(int j=0;j*c[k]<=space;j++) {
B[space] = Math.max(B[space],B[space-j*c[k]]+j*w[k]);
}
}
}
System.out.println(B[v]);
}
}
分组背包问题
有 N 组物品和一个容量是 V 的背包。每组物品有若干个，同一组内的物品最多只能选一个。每件物品的体积是 vij，价值是 wij，其中 i 是组号，j 是组内编号。求解将哪些物品装入背包，可使物品总体积不超过背包容量，且总价值最大。输出最大价值。
输入格式
第一行有两个整数 N，V ，用空格隔开，分别表示物品组数和背包容量。接下来有 N组数据：
每组数据第一行有一个整数 Si，表示第 i 个物品组的物品数量；
每组数据接下来有 Si 行，每行有两个整数 vij,wij，用空格隔开，分别表示第 i 个物品组的第 j 个物品的体积和价值；
输出格式
输出一个整数，表示最大价值。
数据范围
0<N,V≤100
0<Si≤100
0<vij,wij≤100
输入样例
3 5
2
1 2
2 4
1
3 4
1
4 5
输出样例：
8
分析解答：
类比于"01背包问题",其实就是将"01背包问题"中的各个物品进行分组处理，也就是说，“01背包"是每个组的物品数为1时的"分组背包问题”。由此可知，我们可以用处理"01背包"的方法来类比处理"分组背包问题".在这里由于会有分组的产生,我们用来记录价值和空间的数组均变为了二维数组。w[i][j]表示第i组的第j号物品的价值,c[i][j]]表示第i组的第j号物品所占的容量。
import java.util.Scanner;
public class Main{
static int[] B = new int[200]; //状态数组
static int[][] w = new int[200][200]; //表示第i组第j个物品的价值
static int[][] c = new int[200][200]; //表示第i组的第j个物品的容量
static int[] g = new int[200]; //用来记录各个分组的物品数量
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
int n = sc.nextInt(); //表示分组的个数
int v = sc.nextInt(); //表示背包的容量
for(int i=1;i<=n;i++){
g[i] = sc.nextInt();
for(int j=1;j<=g[i];j++){
c[i][j] = sc.nextInt(); //第i组的第j个物品的容量
w[i][j] = sc.nextInt(); //第i组第j个物品的价值
}
}
sc.close();
for(int i=1;i<=n;i++){
for(int j=v;j>=1;j--){
for(int k=1;k<=g[i];k++){
if(c[i][k] <= j){
B[j] = Math.max(B[j],B[j-c[i][k]]+w[i][k]);
}
}
}
}
System.out.println(B[v]);
}
}
二维背包
有 N 件物品和一个容量是 V 的背包，背包能承受的最大重量是 M。每件物品只能用一次。体积是 vi ，重量是 mi，价值是 wi。求解将哪些物品装入背包，可使物品总体积不超过背包容量，总重量不超过背包可承受的最大重量，且价值总和最大。输出最大价值。
输入格式
第一行两个整数，N，V, M ，用空格隔开，分别表示物品件数、背包容积和背包可承受的最大重量。接下来有 N行，每行三个整数 vi,mi,wi，用空格隔开，分别表示第 i件物品的体积、重量和价值。
输出格式
输出一个整数，表示最大价值。
数据范围
0<N≤1000
0<V,M≤100
0<vi,mi≤100
0<wi≤1000
输入样例
4 5 6
1 2 3
2 4 4
3 4 5
4 5 6
输出样例：
8
分析解答：
类似于"01"背包问题,根据题干,除了对背包又多加了一个重量m的限制外,其余均和"01背包"是一样的.状态转移方程为B[v][m] = max{B[v][m],B[v-t[i]][m-r[k]]}
import java.util.Scanner;
/*
二维背包问题
*/
public class TwoKnapsack {
static int[] t = new int[1001]; //表示各个物品的体积
static int[] r = new int[1001]; //表示各个物品的容积
static int[] w = new int[1001]; //表示各个物品的价值
static int[][] B = new int[101][101]; //表示当前状态的值
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt(); //表示物品的数量
int v = sc.nextInt(); //表示背包的体积是v
int m = sc.nextInt(); //表示背包可以承受的重量为w
for(int i=1;i<=n;i++) {
t[i] = sc.nextInt();
r[i] = sc.nextInt();
w[i] = sc.nextInt();
}
sc.close();
for(int i=1;i<=n;i++) {
for(int j=v;j>=1;j--) {
for(int k=m;k>=1;k--) {
if(t[i]<=j && r[i]<=k) {
B[j][k] = Math.max(B[j][k], B[j-t[i]][k-r[i]]+w[i]);
}
}
}
}
System.out.println(B[v][m]);
}
}
以上即是对背包动规一些经典问题的简单分析,其中最关键的是要理解"01背包问题"，其它背包问题均是在其基础上的变形。
