动态规划

动态规划即将大问题转换成相应的小问题通过解决小问题进而解决大问题。
什么时候用动态规划呢：

1.最优化原理（最优子结构性质）

最优化原理可这样阐述：一个最优化策略具有这样的性质，不论过去状态和决策如何，对前面的决策所形成的状态而言，余下的诸决策必须构成最优策略。简而言之，一个最优化策略的子策略总是最优的。一个问题满足最优化原理又称其具有最优子结构性质。

图2

例如图2中，若路线I和J是A到C的最优路径，则根据最优化原理，路线J必是从B到C的最优路线。这可用反证法证明：假设有另一路径J’是B到C的最优路径，则A到C的路线取I和J’比I和J更优，矛盾。从而证明J’必是B到C的最优路径。

最优化原理是动态规划的基础，任何问题，如果失去了最优化原理的支持，就不可能用动态规划方法计算。动态规划的最优化理在其指标函数的可分离性和单调性中得到体现。根据最优化原理导出的动态规划基本方程是解决一切动态规划问题的基本方法。

可以看出，例1是满足最优化原理的。

2.无后向性

将各阶段按照一定的次序排列好之后，对于某个给定的阶段状态，它以前各阶段的状态无法直接影响它未来的决策，而只能通过当前的这个状态。换句话说，每个状态都是过去历史的一个完整总结。这就是无后向性，又称为无后效性。

如果用前面的记号来描述无后向性，就是：对于确定的xk，无论p1,k-1如何，最优子策略pkn*是唯一确定的，这种性质称为无后向性。

[例3] Bitonic旅行路线问题

欧几里德货郎担问题是对平面给定的n个点确定一条连结各点的、闭合的最短游历路线问题。图3(a)给出了七个点问题的解。Bitonic旅行路线问题是欧几里德货郎担问题的简化，这种旅行路线先从最左边开始，严格地由左至右到最右边的点，然后再严格地由右至左到出发点，求路程最短的路径长度。图3（b）给出了七个点问题的解。

图3

这两个问题看起来很相似。但实质上是不同的。为了方便讨论，我将每个顶点标记了号码。由于必然经过最右边的顶点7，所以一条路(P1-P2)可以看成两条路（P1-7）与(P2-7)的结合。所以，这个问题的状态可以用两条道路结合的形式表示。我们可以把这些状态中，两条路中起始顶点相同的状态归于一个阶段，设为阶段[P1,P2]。

那么，对于Bitonic旅行路线问题来说，阶段[P1,P2]如果可以由阶段[Q1,Q2]推出，则必须满足的条件就是:P1<Q1或P2<Q2。例如，阶段[3,4]中的道路可以由阶段[3,5]中的道路加一条边4-5得出，而阶段[3,5]的状态却无法由阶段[3,4]中的状态得出，因为Bitonic旅行路线要求必须严格地由左到右来旅行。所以如果我们已经知道了阶段[3,4]中的状态，则阶段[3,5]中的状态必然已知。因此我们可以说，Bitonic问题满足无后向性，可以用动态规划来解决。

有些问题乍一看好像有后向性，但如果按照某种合理的方式重新划分阶段，就可以发现其本质上是无后向性的，所以关键是阶段的合理划分，这一点将在动态规划的技巧中详细阐述。

3.子问题的重叠性

在例1中我们看到，动态规划将原来具有指数级复杂度的搜索算法改进成了具有多项式时间的算法。其中的关键在于解决冗余，这是动态规划算法的根本目的。动态规划实质上是一种以空间换时间的技术，它在实现的过程中，不得不存储产生过程中的各种状态，所以它的空间复杂度要大于其它的算法。以Bitonic旅行路线问题为例，这个问题也可以用搜索算法来解决。动态规划的时间复杂度为O(n2)，搜索算法的时间复杂度为O(n!)
，但从空间复杂度来看，动态规划算法为O(n2)，而搜索算法为O(n)，搜索算法反而优于动态规划算法。选择动态规划算法是因为动态规划算法在空间上可以承受，而搜索算法在时间上却无法承受，所以我们舍空间而取时间。

设原问题的规模为n，容易看出，当子问题树中的子问题总数是n的超多项式函数，而不同的子问题数只是n的多项式函数时，动态规划法显得特别有意义，此时动态规划法具有线性时间复杂性。所以，能够用动态规划解决的问题还有一个显著特征：子问题的重叠性。这个性质并不是动态规划适用的必要条件，但是如果该性质无法满足，动态规划算法同其他算法相比就不具备优势。

通常有三步 1 创建一个数组来存储历史数据（小问题的解）
2 找出大问题和小问题之间的表达式（动态规划转移方程）
3 找出初始值

通过几道题来看一下

class Solution {
    public int maxSubArray(int[] nums) {
        int max_data=nums[0];
        int pre=0;
        if(nums.length<=0){
            return 0;
        }
        for(int i=0;i<nums.length;i++){
            pre=Math.max(nums[i]+pre,nums[i]);//保证第一个pre一定是第一个数，避免了全负数的情况
            max_data=Math.max(max_data,pre);//此处即转换成子问题了，此处要知道一件事，即使加上负数变的是pre 而不是												max_data有疑问可以写一个数组试一下。
        }
        return max_data;
    }
}

这个是可以按那三步走的一个题，首先创建一个二维数组来保存历史数据，因为向右和向下是两个选择所以要创建一个二维数组 int [][] nums=new int [m][n];
再考虑一下边界条件，即当只有一行一列时就只能往右或往下，还有数组为空的情况（边界很重要）
然后找动态规划方程，走到一格只有两种情况，一是从上面下来二是从左边向右走的。同样上一步也是这两步。代码如下，肯定会有改进的地方，但是刚开始没必要为了一点点改进而花费大量时间，先熟悉这个思路再进行改进吧。

class Solution {
    public int uniquePaths(int m, int n) {
        int [][] nums=new int [m][n];
        if(m<=0||n<=0){
            return 0;
        }

            for(int i=0;i<n;i++){
                nums[0][i]=1;
            }
        
      
            for(int i=0;i<m;i++){
                nums[i][0]=1;
            }
            

        for(int i=1;i<m;i++){
            for (int j=1;j<n;j++){
                nums[i][j]=nums[i][j-1]+nums[i-1][j];
            }
        }
        return nums[m-1][n-1];
    
}}

这个同理，要得到最大值即为比较中间一个和旁边两个的大小

class Solution {
    public int rob(int[] nums) {
        if(nums.length==0 || nums==null){
            return 0;
        }
        if(nums.length==1){
            return nums[0];
        }
        int [] dp=new int [nums.length];
        dp[0]=nums[0];
        dp[1]=Math.max(nums[0],nums[1]);
        for(int i=2;i<nums.length;i++){
            dp[i]=Math.max(dp[i-2]+nums[i],dp[i-1]);
        }
        return dp[nums.length-1];
    }
}

虽然做了几道题，但遇到稍微难点的题还是很难自己写出来，总是不得不借助题解，这样是不是不好，如果有好的办法请告诉我一下，谢谢！