一）基本理解：

1、动态规划定义：将将原问题拆解为若干个子问题，同时保留子问题的答案，使得每个子问题只求解一次最终得到原问题的答案。         这样一听总感觉和分治算法很像，其实动态规划就是将分治递归算法转化成了非递归形式，减少了系统栈的调用，使用循环来解决问题。

2、动态规划算法的说白了就是找到整个问题的全局最优解，这也是与贪心算法寻找局部最优解的本质区别。

3、通常我们可以先用从顶向下的思考方式来写出递归分治的代码，然后再联想从低向下的思想来转化为动态规划代码.

4、无论是递归还是动态规划首先我们一定要找到这个问题的最小子问题，即一眼就能看出结果的那个小问题，然后根据这个关系来找递归关系。

5、每次利用数组时，下标通常从1开始，省去很多麻烦。

---

二）记忆化搜索与动态规划

上图介绍了递归分治与动态规划的联系。

只有当具有重叠子问题以及最优子结构才能使用这两种方法。

最优子结构：由子问题的最优解可以推出大问题的最优解。

1、记忆化搜索就是建立一个数组去保存之前所计算出来的结果，每次先看看里面有没有已经计算出来的值，有直接取，没有再去递归计算。

2、动态规划就是去掉递归式，直接用数组去求解。

---

三）动态规划与记忆化搜索模板：

下面是以leetCode70题，爬楼梯为例。

1、动态规划：

 2、记忆化搜索：

1、无论是动态规划还是记忆化搜索一开始都会有个if判断，该判断出现的意义就是保证数组下标的有效性。

2、if判断中的条件主要来自于下面递归函数参数的传递，以及动态规划中数组下标的访问。

上题中动态规划每次要访问arr[n-1]和arr[n-2]所以为了保证数组下标不越界因此if条件是当n<=2时......

在记忆化搜索中同理传入n-1和n-2，于是if条件也是n<=2时...

---

四）leetCode例题：

        1、343整数拆分：

给定一个正整数 n ，将其拆分为 k 个 正整数 的和（ k >= 2 ），并使这些整数的乘积最大化。返回 你可以获得的最大乘积 。

最小子问题是当n<=2时，结果为只能为1*1=2.

每次取最大值时，三种情况：

1、最大值是之前保留的那个res_max。

2、不对第二个数进行分割的乘积。

3、对第二个数进行分割的乘积。

1、记忆化搜索： 

class Solution {
    public int arr[];
    public int integerBreak(int n) {
        arr=new int[n];
        Arrays.fill(arr,-1);
        return  myFun(n);
    }
    //将n传入，就可以返回该数字的乘积最大化结果。
    public int myFun(int n){
        if  (n<=2) return 1;

        int res_max=-1;
        if(arr[n-1]!=-1)
            return arr[n-1];
        
        //n-i表示i前面的那个数
        for(int i=1;i<n;i++){
           res_max=myMax(res_max,i*(n-i),i*myFun(n-i));
        }
        arr[n-1]=res_max;     
        return arr[n-1];
    }
    public int myMax(int i,int j,int k){
        return Math.max(i,Math.max(j,k));
    }
}

2、动态规划：

class Solution {
   //动态规划：
    public int integerBreak(int n){
        if  (n<=2) return 1;

        int arr[]=new int[n+1];
        Arrays.fill(arr,-1);
        arr[1]=1;arr[2]=1;

        for(int i=3;i<=n;i++){
            for(int j=1;j<i;j++){
                arr[i]=max3(arr[i],j*(i-j),j*arr[i-j]);
            }
        }
        return arr[n];
    }

    public int max3(int i,int j,int k){
        return Math.max(i,Math.max(j,k));
    }
   
}

        2、198打家抢劫.

学会动态转移方程的使用，不同的动态转移方程得到的函数是不一样的。

下面的代码解析用记忆搜索和动态规划分别采用不同的状态转移进行求解。

class Solution {
    //记忆搜索法：
    private int arr[];
    public int rob(int[] nums) {
        arr=new int[nums.length];
        Arrays.fill(arr,-1);
        return myFun1(nums,0);//状态转移方程[i,len-1]
        //return myFun2(nums,nums.length-1); //状态转移方程为[0,i]；
    }
    /**状态转移方程为[i,len-1] */
    private int myFun1(int[] nums,int index){
        //因为下面递归时会传入i+2，可能造成数组下标越界
        if  (index>=nums.length)
            return 0;
        if(arr[index]==-1)
            for(int i=index;i<nums.length;i++)
                arr[index]=Math.max(arr[index],(myFun1(nums,i+2)+nums[i]));
        return arr[index];
    }

    //状态转移方程：[0,index];
    private int myFun2(int[] nums,int index){
        if(index<0) return 0;
       if(arr[index]==-1){
           for(int i=0;i<=index;i++){
               arr[index]=Math.max(arr[index],(nums[i]+myFun2(nums,i-2)));
           }
       }
        return arr[index];
    }


    //动态规划：
    /**状态转移方程是从[0,i],所以最后返回的值肯定是arr[len-1] */
    public int rob1(int[] nums) {
        int len=nums.length;
        if(len<=1) return len==0?0:nums[0];
        int arr[]=new int[len];
        Arrays.fill(arr,-1);

        arr[0]=nums[0];
        arr[1]=Math.max(nums[0],nums[1]);
        /**状态转移方程是从[0,i] */
        for(int i=2;i<len;i++){
            for(int j=0;j<=i;j++){
                arr[i]=Math.max(nums[j]+(j-2<0?0:arr[j-2]),arr[i]);
            }
        }
        return arr[len-1];
    }

    /**状态转移方程为[i,n-1],所以最后返回的肯定是arr[0]*/
    public int rob2(int [] nums){
        int  n=nums.length;
        if(n==0) return 0;

        int arr_3[]=new int[n];
        Arrays.fill(arr_3,-1);
        arr_3[n-1]=nums[n-1];

        for(int i=n-2;i>=0;i--){
            for(int j=i;j<n;j++){
                arr_3[i]=Math.max(arr_3[i],nums[j]+(j+2<n?arr_3[j+2]:0));
            }
        }
        return arr_3[0];
    }
}

        3、0-1背包问题：

问题描述：有n个物品，他们的质量和价值分别为w[i]和v[i]，现在有一个容量为C的背包，要求选择性的放入物品使该背包的价值最大。

乍一看这个问题求最优解，一看就是典型的动态规划问题，但是仔细分析发现这个问题与之前的不同，之前的动态规划问题都是一个约束条件，这个问题有两个一个是质量一个是价值，所以肯定要开辟一个二维数组。

1、状态转移方程：我们将下标为i的物品放进去价值最大，或者不将第i个物品放进去，因为容积不足了因而得到的最大价值。

 

import org.apache.commons.compress.archivers.ar.ArArchiveEntry;

import java.util.Arrays;
import java.util.OptionalInt;

public class test {
    public static int arr[][];
    //第一代0-1背包问题：时间和空间复杂度都是O(n*c)
    //记忆化搜索：
    //1、状态转移方程：[0,index]这个范围内的
    public static int bag01(int v[], int w[], int c) {
        int n = w.length;
        /*n行表示n个物品，C+1列表示容量是从[0,C]*/
        arr = new int[n][c + 1];
        Util.Arrays_fill(arr, -1);  //将数组元素填充为0自己写的函数
        return myBag(v, w, n - 1, c); //考虑将下标为n-1的物品放到容积为C的背包中的最大价值
    }
    private static int myBag(int[] v, int[] w, int index, int c) {
        //下面调用递归时会填入参数index - 1和c - w[index]，所以要考虑数组索引>0
        if (index < 0 || c < 0) return 0;

        if (arr[index][c] == -1) {
            //1、不将第i个物品放进去背包的最大值
            arr[index][c] = myBag(v, w, index - 1, c);
            //2、将物品放进去背包的价值最大值
            if (c >= w[index])
                arr[index][c] = Math.max(arr[index][c], v[index] + myBag(v, w, index - 1, c - w[index]));
        }

        return arr[index][c];
    }
    //动态规划：
    public static int bag01_D_ND(int v[], int w[], int c) {
        int n = v.length;
        //下面要用到n-1所以此处要保证n-1不能小于零
        if (n == 0) return 0;

        int[][] arr = new int[n][c + 1];
        Util.Arrays_fill(arr, -1); //将数组元素填充为0自己写的函数

        //初始化第一行元素
        for (int i = 0; i <= c; i++) {
            arr[0][i] = (i >= w[0] ? v[0] : 0);
        }

        //初始化1~n-1列
        for (int i = 1; i < n; i++) {
            for (int j = 0; j <= c; j++) {
                //1、默认是上一行的元素值，即不将该物品放进去
                arr[i][j] = arr[i - 1][j];
                //2、开始考虑若将该物品放进去
                if (j >= w[i])
                    arr[i][j] = Math.max(arr[i][j],v[i]+ arr[i - 1][j - w[i]]);
            }
        }
        return arr[n - 1][c];
    }

    //动态规划优化版，O(2*c),只开辟两行数组。
    /**1、我们发现每次调用数组时只使用数组的相邻两行，于是从此开始优化
     * 2、循环使用就取模运算*/
    public static int bag01_D_C(int v[], int w[], int c) {
        int n = v.length;
        //下面要用到n-1所以此处要保证n-1不能小于零
        if (n == 0) return 0;

        int[][] arr = new int[2][c + 1];
        Util.Arrays_fill(arr, -1);

        //初始化第一行元素
        for (int i = 0; i <= c; i++) {
            arr[0][i] = (i >= w[0] ? v[0] : 0);
        }

        //初始化1~n-1列
        for (int i = 1; i < n; i++) {
            for (int j = 0; j <= c; j++) {
                //1、默认是上一行的元素值，即不将该物品放进去
                arr[i%2][j] = arr[(i - 1)%2][j];
                //2、开始考虑若将该物品放进去
                if (j >= w[i])
                    arr[i%2][j] = Math.max(arr[i%2][j],v[i]+ arr[(i - 1)%2][j - w[i]]);
            }
        }
        return arr[(n-1)%2][c];
    }




    public static void main(String[] args) {
        int[] weight = {1, 2, 3};
        int[] value = {6, 10, 12};
        int c = 5;
        System.out.println(bag01_D_C(value, weight, c));//22
    }

}