动态规划（1）------ 背包动规

动态规划一般可分为线性动规，区域动规，树形动规，背包动规四类。动态规划程序设计是对解最优化问题的一种途径、一种方法，而不是一种特殊算法.不像搜索或数值计算那样，具有一个标准的数学表达式和明确清晰的解题方法。动态规划程序设计往往是针对一种最优化问题，由于各种问题的性质不同，确定最优解的条件也互不相同，因而动态规划的设计方法对不同的问题，有各具特色的解题方法，而不存在一种万能的动态规划算法，可以解决各类最优化问题。

对于背包动规，其常见的经典问题有：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背包问题"，其它背包问题均是在其基础上的变形。