动态规划算法

1. 应用场景-背包问题

背包问题：有一个背包，容量为4磅 ， 现有如下物品

要求如下：

1. 要求达到的目标为装入的背包的总价值最大，并且重量不超出
2. 要求装入的物品不能重复

2. 动态规划算法介绍

1. 动态规划(Dynamic Programming)算法的核心思想是：将大问题划分为小问题进行解决，从而一步步获取最优解的处理算法

2. 动态规划算法与分治算法类似，其基本思想也是将待求解问题分解成若干个子问题，先求解子问题，然后从这些子问题的解得到原问题的解。

3. 与分治法不同的是，适合于用动态规划求解的问题，经分解得到子问题往往不是互相独立的。 ( 即下一个子阶段的求解是建立在上一个子阶段的解的基础上，进行进一步的求解 )

4. 动态规划可以通过填表的方式来逐步推进，得到最优解.

3. 思路

算法的主要思想，利用动态规划来解决。每次遍历到的第i个物品，根据w[i]和v[i]来确定是否需要将该物品放入背包中。即对于给定的n个物品，设v[i]、w[i]分别为第i个物品的价值和重量，C为背包的容量。再令v[i][j]表示在前i个物品中能够装入容量为j的背包中的最大价值。

构建表格

上图中：第一行全部为0，表示前0个物品中能够装入容量为1，2，3，4磅的物品的价值都为0，因为前0个物品就是一个物品都没有，所以，无论背包有多少磅，其装入的价值都为0。第一列全部为0，就是背包可以装入的重量为0磅，所以什么物品都不能放入其中。

上图中，v[1][1]中背包能够承受1磅，在前一个物品中选择，前一个物品就只有吉他，所以就只能选择吉他进入包中，价值为v[1][1]=1500。v[1][2]中背包能够装入2磅，从前一个物品中选择，所以还是只能选择吉他 v[1][2] = 1500。注意不能重复放入物品，所以v[1][2] = 1500 而不是3000。v[1][3]，v[1][4]同理。

上图中，v[2][1]中，背包能够承受1磅，可以选择的物品是前两个物品即吉他（1磅）和音响（4磅），所以只能选择吉他，所以v[2][1]的值是拷贝自v[1][1]的值。 即v[2][1]的上一格。 v[2][2]中，背包能够承受2磅，还是只能存放吉他，所以v[2][2]的值是拷贝自v[1][2]的值。 v[2][3]同理，v[2][4]中，背包能够承受4磅，吉他和音响不能同时入包，只能选择一个，所以选择价值大的音响。所以v[2][4] = 3000.

上图中，v[3][1]只能承受1磅，从前三个物品中选择（吉他，音响，电脑），由于只能承受1磅，所以只能选择吉他，所以v[3][1] = 1500 拷贝自v[2][1]. v[3][2]同理。v[3][3]中能够承受3磅，所以选择电脑，所以v[3][3] = 2000. v[3][4]中可以承受4磅，所以可以选择吉他和电脑或者只选择音响，因为吉他和电脑的总价值比音响大，所以选择吉他和电脑，所以v[3][4] = 3500.

总结
算法的主要思想，利用动态规划来解决。每次遍历到的第i个物品，根据w[i]和v[i]来确定是否需要将该物品放入背包中。即对于给定的n个物品，设v[i]、w[i]分别为第i个物品的价值和重量，C为背包的容量。再令v[i][j]表示在前i个物品中能够装入容量为j的背包中的最大价值。

(1) v[i][0]=v[0][j]=0; //表示 填入表 第一行和第一列是0

(2) 当w[i]> j 时：v[i][j]=v[i-1][j] // 当准备加入新增的商品的容量大于 当前背包的容量时，就直接使用上一个单元格的装入策略

(3) 当j>=w[i]时： v[i][j]=max{v[i-1][j], v[i]+v[i-1][j-w[i]]} // 当准备加入的新增的商品的容量小于等于当前背包的容量.

装入的方式:

v[i-1][j]： 就是上一个单元格的装入的最大值

v[i] : 表示当前商品的价值

v[i-1][j-w[i]] ： 装入i-1商品，到剩余空间j-w[i]的最大值

4. 代码实现

public class KnapsackProblem {
    public static void main(String[] args) {
        int[] w = {1, 4, 3}; // 保存物品的数量
        int[] val = {1500, 3000, 2000}; // 物品的价值
        int m = 4; // 背包的容量
        int n = val.length; // 物品的个数
        int[][] v = new int[n + 1][m + 1]; // 二维数组 v[i][j]表示在前i个物品中能够装入容量为j的背包中的最大价值。


        // 初始化第一行和第一列
        for (int i = 0; i < v.length; i++) {
            v[i][0] = 0;
        }
        for (int i = 0; i < v[0].length; i++) {
            v[0][i] = 0;
        }

        // 开始处理
        for (int i = 1; i < v.length; i++) {
            for (int j = 1; j < v[0].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]]);
                }
            }
        }


        // 输出二维数组
        for (int i = 0;i<v.length;i++){
            System.out.println(Arrays.toString(v[i]));
        }

    }
}