经典算法 - 动态规划算法及背包问题（01背包与完全背包）

动态规划

动态规划算法通常用于求解具有某种最优解的问题

基本思想也是将待求解问题分解成若干个子问题，先求解子问题，然后从这些子问题的解得到原问题的解

与分治法不同的是，动态规划分解得到的子问题往往不是互相独立的，即上一个子问题解可能为下一个子问题的条件（通常可以将结果填入表格）

---

背包问题

有一个背包容量为4kg，现在有以下物品

物体	重量	价格
吉他	1	1500
音响	4	3000
电脑	3	2000

现要求装入背包的物体价值最大，且不能超重

其中：

• 01背包问题：物品有限，每种物品仅有一件，只能选择放、不放
• 有界背包问题：限定物品最多只能选择一定个数
• 无界背包问题（完全背包问题）：物品无限

有界、无界背包问题都可以转换成01背包问题

对于背包问题，不同阶段（背包1kg,3kg,4kg / 只能选吉他,可选吉他音响…），存在多种解，而动态规划可以得到最优解

通过表格最能表现动态规划：行表示物品数，列表示背包容量，表格中值为最大价值
-> 当只有吉他时，不管背包容量多少最大价值都为1500；物品为吉他+音响，当背包容量为4kg时最大价值为3000

	0kg	1kg	2kg	3kg	4kg
	0	0	0	0	0
吉他	0	1500	1500	1500	1500
吉他+音响	0	1500	1500	1500	3000
吉他+音响+电脑	0	1500	1500	2000	3500

解决思路

1. 把物品的重量定义数组w[]，、价值为val[]，且物品的序号对应

2. 定义上面的表格v[][]

3. 对应表格，有3条规则

   1. 第一行v[0][j]和第一列v[i][0]=0,数组默认为0不处理
   2. 当前新增物品重量大于背包容量w[i-1] > j，选择为未新增物品时的最大价值， v[i][j] = v[i-1][j]
   3. 当前新增物品重量不大于背包容量w[i-1] <= j，选择 {上一行最大价值，当前行物品+剩余重量能放的物品最大价值} 的最大值
      v[i][j] = Math.max( v[i-1][j] , val[i-1] + v[i-1][j-w[i-1]] );

4. 如果要打印放了什么物品，就需要详细设计3.3
   设置二维数组produce[][]对应v[][],记录放入商品情况，只有3.3中出现当前行物品+剩余重量能放的物品为最大价值时标记为1，然后从v[3][4]往前打印

Java实现01背包问题

package com.company.十种算法.dynamic;

import java.util.Arrays;

/**
 * Author : zfk
 * Data : 10:40
 * 动态规划解决背包问题(01背包问题)
 */
public class KnapsackProgram {

    public static void main(String[] args) {
        //物品的重量
        int[] w ={1,4,3};
        //物品的价值
        int[] val = {1500,3000,2000};
        //背包的容量
        int m = 4;
        //物品的个数
        int n = val.length;

        //v[i][j]表示 前i个物体中能装入容量为j的背包的最大价值
        //v[0][j]和v[i][0]都等于0，所以需要+1
        int[][] v = new int[n+1][m+1];

        int[] newV = new int[m+1];

        //记录放入商品情况
        int[][] produce = new int[n+1][m+1];

        package01(val,w,V,produce);


    }


    public static void package01(int[] val,int[] w,int[][] v,int[][] produce){

        //第一行，第一列v[0][j]和v[i][0]=0,默认为0不处理

        //动态规划处理(第一行，第一列不处理)
        for (int i = 1;i < v.length;i++){
            for (int j = 1;j < v[i].length;j++){
                //当前行：物品重量大于背包重量 -> 选择上一行最大价值
                if (w[i-1] > j){
                    v[i][j] = v[i-1][j];
                }
                //物品重量小于背包重量 -> 选择 {上一行最大价值，当前行物品+剩余重量能放的物品最大价值} 的最大值
                else{
                    //v[i][j] = Math.max( v[i-1][j] , val[i-1] + v[i-1][j-w[i-1]] );

                    //记录物品存放的情况
                    if (v[i-1][j] < val[i-1] + v[i-1][j-w[i-1]]){
                        v[i][j] = val[i-1] + v[i-1][j-w[i-1]];
                        //存放多个商品，需要记录
                        produce[i][j] = 1;
                    }else {
                        v[i][j] = v[i-1][j];
                    }
                }
            }
        }

        for (int i = 0;i < v.length;i++){
            for (int j = 0;j < v[i].length;j++){
                System.out.print(v[i][j]+" ");
            }
            System.out.println();
        }


        System.out.println("==============");
        //输出放入的商品（最后放入的情况）
        int i = produce.length -1;
        int j = produce[0].length -1;
        while (i > 0 && j > 0){

            if (produce[i][j] == 1){
                System.out.println("第"+i+"个商品放入");
                System.out.println("i = "+i+", j = "+ j);
                j -= w[i-1];
            }
            i--;
        }
    }
}

结果：

简化：一维数组代替二维数组

前面的01背包问题使用二维数组v[][]来画表格存储结果，实际上有很多空间都浪费的

可以使用一维数组简化，降低空间复杂度

    public static void package01New(int[] val,int[] w,int[] v){

        for (int i = 0;i < w.length;i++){
            for (int j = v.length -1;j >= 1 ;j--){

                if (w[i] <= j){
                    v[j] =v[j] > v[j - w[i] ] + val[i] ? v[j] : v[j - w[i] ] + val[i];
                }
            }
        }
        Arrays.stream(v).forEach(System.out::print);

        System.out.println("最大价值："+v[v.length -1]);
    }

使用v[j] =v[j] > v[j - w[i] ] + val[i] ? v[j] : v[j - w[i] ] + val[i];
代替v[i][j] = Math.max( v[i-1][j] , val[i-1] + v[i-1][j-w[i-1]] );

即一维数组，经过n次循环，也能达到二维数组的效果

第一次循环：

0kg	1kg	2kg	3kg	4kg
0	1500	1500	1500	1500

第二次循环：
v[4] = v[j - w[i] ] + val[i] = v[0] + val[1] = 0 + 3000 = 3000

0kg	1kg	2kg	3kg	4kg
0	1500	1500	1500	3000

第三次循环：

v[4] = v[j - w[i] ] + val[i] = v[1] + val[2] = 1500 + 2000 = 3500

0kg	1kg	2kg	3kg	4kg
0	1500	1500	2000	3500

这里有一个要注意点：第二层循环要倒着

如果正着，正着循环无法计算，第一次循环都是 v[j - w[i] ] + val[i]

---

完全背包问题

实际上上面的第二层循环正着就是完全背包问题的最优解了：
每一趟v[j] =v[j] > v[j - w[i] ] + val[i] ? v[j] : v[j - w[i] ] + val[i]
v[j]表示如果没有加入新商品，能放入的最大价值，即二维数组v[][]的上一层
v[j - w[i] ] + val[i]表示新商品的价值加上剩余空间的最大价值

这里就没有考虑商品的数量，就是完全背包问题

小小的优化一下，每次内循环从w[i]开始

  public static void packageComplete(int[] val,int[] w,int[] v){
        for (int i = 0;i < w.length;i++){
            for (int j = w[i];j < v.length ;j++){

                if (w[i] <= j){
                    v[j] =v[j] > v[j - w[i] ] + val[i] ? v[j] : v[j - w[i] ] + val[i];
                }
            }
        }
        Arrays.stream(v).forEach(System.out::println);

        System.out.println("最大价值："+v[v.length -1]);
    }

我们修改一下物品价值：

结果：