动态规划（DP）算法

参考https://blog.csdn.net/libosbo/article/details/80038549

动态规划是求解决策过程最优化的数学方法。利用各个阶段之间的关系，逐个求解，最终求得全局最优解，需要确认原问题与子问题、动态规划状态、边界状态、边界状态结值、状态转移方程。

以下每个例题，注意分析迭代关系是怎么找到的。

一、爬楼梯leetcode70:

You are climbing a stair case. It takes n steps to reach to the top.

Each time you can either climb 1 or 2 steps. In how many distinct ways can you climb to the top?

Note: Given n will be a positive integer.

Example 1:

Input: 2
Output: 2
Explanation: There are two ways to climb to the top.
1. 1 step + 1 step
2. 2 steps

Example 2:

Input: 3
Output: 3
Explanation: There are three ways to climb to the top.
1. 1 step + 1 step + 1 step
2. 1 step + 2 steps
3. 2 steps + 1 step

方法一：利用n个楼梯的步数，与n-1还有n-2之间的关系可以退出，f(n)==f(n-1)+f(n-2),相当于是直接考虑为n-1再上一步，和n-2直接上两步，不能考虑n-2有两种走法（一步一步，和一次两步，一步一步的会和n-1中的重复，导致算多了），最后不断的迭代直至可以n==1或者n==2，可以直接求出结果。

这个方法相当于是根据各个阶段之间的关系，列出迭代关系，并且写出临界解，从而结束递归的过程，否则将一直递归下去（所有的递归都是如此，如果没有边界条件提前结束递归，递归将不会停止）

这个时间复杂度是2^n相当于是一颗二叉树来着，leetcode显示time limit exceed

 int climbStairs(int n) {
         if(n==||n==){
             return n;
         }
         return climbStairs(n-)+climbStairs(n-);
    }

方法二：利用迭代来实现尾递归

由于方法一是利用了尾递归来实现算法，考虑采用迭代来实现递归，并且递归本身算法复杂度是要远远大于其对应的迭代循环算法复杂度的，所以考虑利用迭代来减少时间复杂度。两种方法的差别在于递归是从上往下算，迭代是从下往上算。

 class Solution {
 public:
     int climbStairs(int n) {
         vector<int>iteration(n+,); //initializition
         iteration[]=;
         iteration[]=;
         int i=;
         while(i<n+){
             iteration[i]=iteration[i-]+iteration[i-];
             i++;
         }
         return iteration[n];
     }
 };

二、抢劫犯问题leetcode198

You are a professional robber planning to rob houses along a street. Each house has a certain amount of money stashed, the only constraint stopping you from robbing each of them is that adjacent houses have security system connected and it will automatically contact the police if two adjacent houses were broken into on the same night.

Given a list of non-negative integers representing the amount of money of each house, determine the maximum amount of money you can rob tonight without alerting the police.

题目分析：这个题目的分析关键在于DP算法中状态转移方程的求解，也就是求解是迭代关系，可以发现对于第i个房间而言，如果不抢劫第i个房间那么就是i-1个的抢劫数目，如果抢劫第i个房间那么就是一定不能抢劫i-1个房间，相当于是i-2个房间的抢劫数目，两者时间的最大值即可，从而成功得出迭代关系。

注意自身在分析问题时的错误：

一：在无法的出迭代关系的情况下，没有考虑根据题意对可能的情况进行分类，注意两个题目都是进行了分类的讨论，才得以顺利的得出迭代关系，并且盲目的理解为迭代关系一定是两者之间的和，没有考虑到最大值得情况。

二：在考虑迭代关系时一定要思考如何引入第i-1个和第i-2个问题的解，这道题就是通过分类讨论，成功剥离出了i-1和i-2的情况；迭代关系的另一个要素是如何把i与i-1和i-2之间的关系找到

三：在考虑迭代关系时一定把i考虑成足够大，因为在代码实现过程中i很小的情况是直接给出的，直接赋值的（对于有dp数组而言），i很小的情况下只是考虑为边界条件，作为循环的起始或者是迭代的结束。所以考虑迭代关系时一定不要具体化i而是直接假设i足够大去考虑。

求取迭代关系的步骤：

1、根据题意分类讨论，分类讨论一定要达到引入i-1和i-2的解

2、挖掘i和i-1还有i-2之间的关系

3、边界条件确认

方法一、使用迭代法

 class Solution {
 public:
     int rob(vector<int>& nums) {
         if(nums.empty()) return ;
         if(nums.size()==) return nums[];
         vector<int>dp(nums.size(),);
         dp[]=nums[];
         dp[]=max(nums[],nums[]);
        for(int i=;i<nums.size();i++){
             dp[i]=max(dp[i-]+nums[i],dp[i-]);
         }
         return dp[nums.size()-];
     }
 };

方法二、使用递归算法

class Solution {
public:
    int rob(vector<int>& nums) {
        int size=nums.size();
        if(size==) return ;
        if(size==) return nums[];
        if(size==) return max(nums[],nums[]);
        vector<int>a1(nums.begin(),nums.end()-);
        vector<int>a2(nums.begin(),nums.end()-);
        return max(rob(a1),rob(a2)+nums[size-]);

    }
};

可以发现这种方法再次出现了time limit exceed，时间复杂度是O(2^n),以后不用再考虑递归的DP算法了，直接使用迭代，时间复杂度降低很多。

以上两道例题都是相似的，接下来的例题稍有不同，要重点理解。

三、最大子段和leetcode53（重点理解）

Given an integer array nums, find the contiguous subarray (containing at least one number) which has the largest sum and return its sum.

注意自身在分析问题时的错误：

在分析问题的时候没有灵活变通，直接考虑前i个连续子数组数组的最大值，将无法进行分类讨论，无法得到递归关系，并且在考虑递归关系时也是直接考虑了i与i-1还有i-2之间的关系，其实可以考虑为i与i-1的关系即可，只要是一种可以迭代出所有情况的关系即可。在不能够得出迭代关系的时候需要变通的考虑，改变dp数组的意义，不需要一步到位，只要保证可以通过dp数组得到最后的结果即可。

code：dp数组表示的是以第i个元素结尾的连续子数组的最大值，最后再寻找dp的最大值

 class Solution {
 public:
     int maxSubArray(vector<int>& nums) {
         int size=nums.size();
         vector<int>dp(size,);
         dp[]=nums[];
         for(int i=;i<size;i++){
             if(dp[i-]>) dp[i]=dp[i-]+nums[i];
             else dp[i]=nums[i];
         }
         int max1=dp[];
         for(int i=;i<size;i++){
             max1=max(max1,dp[i]);
         }
         return max1;
     }
 };

注意，这里判断dp[I-1]的正负来确定迭代关系（这是与之前两道例题都不同的地方），仔细理解根据num[i]正负来确定迭代关系的区别以及孰是孰非。

四、找零钱和leetcode322（非常经典的DP算法，稍复杂）——还未完全理解。。。

You are given coins of different denominations and a total amount of money amount. Write a function to compute the fewest number of coins that you need to make up that amount. If that amount of money cannot be made up by any combination of the coins, return -1.

Example 1:
coins = [1, 2, 5], amount = 11
return 3 (11 = 5 + 5 + 1)

Example 2:
coins = [2], amount = 3
return -1.

Note:
You may assume that you have an infinite number of each kind of coin.

 class Solution {
 public:
     int coinChange(vector<int>& coins, int amount) {
         vector<int>dp(amount+,amount+);
         dp[]=;
         for(int i=;i<=amount;i++){
             for(int m:coins){
                 if(m<=i) dp[i]=min(dp[i],dp[i-m]+);
             }
         }
         if(dp.back()==amount+) return -;
             else return dp.back();
     }
 };

五、三角形——还未完全理解。。。

Given a triangle, find the minimum path sum from top to bottom. Each step you may move to adjacent numbers on the row below.

For example, given the following triangle

[
     [2],
    [3,4],
   [6,5,7],
  [4,1,8,3]
]

The minimum path sum from top to bottom is 11 (i.e., 2 + 3 + 5 + 1 = 11).

这道题目类似于第三题，都是对dp数组的意义进行转换，从而以退为进解决问题。

 class Solution {
 public:
     int minimumTotal(vector<vector<int>>& triangle) {
         int size=triangle.size();
         vector<vector<int>>dp(size,vector<int>(size,INT_MAX));
         dp[][]=triangle[][];
         for(int i=;i<size;i++){
             for(int j=;j<triangle[i].size();j++){
                 if(j==) dp[i][j]=dp[i-][j]+triangle[i][j];
                 if(j==triangle[i].size()-) dp[i][j]=dp[i-][j-]+triangle[i][j];
                 if(j!=&&j!=triangle[i].size()-) dp[i][j]=min(dp[i-][j-]+triangle[i][j],dp[i-][j]+triangle[i][j]);
             }
         }
         return *min_element(dp[size-].begin(),dp[size-].end());
     }
 };