动态规划-看完就会系列

前言

第一眼看到动态规划四个字，我的感觉是，好像很牛逼的样子，是不是很难啊，其实掌握了一定套路后，真没那么难。

描述：

动态规划就是一种解决问题的方法，什么方法呢？就是利用已经知道的解去求解未知问题的解，如果这两个问题之间存在一定的联系，那么就可以用已知解加上这个联系得到未知解了。
比如你想去求1+1+1这个问题的解，那么我告诉你1+1=2，那么1+1+1就是1+1的解再加上1喽，这就是他们之间的联系，所以仔细想一下真没那么难。

动态规划解题步骤

我在写动态规划的时候一般按照四步走：

1. 先把一个大问题进行拆解，拆解成一个一个小问题，然后找到各个问题之间的联系；
2. 这时候已经把问题拆解了并且也知道了各个问题的联系，那么需要定义一个状态，也就某一个小问题的状态；
3. 然后根据状态和状态间的联系写出状态转移方程；
4. 最后根据状态转移方程进行编码即可。

最难和最重要的就是2，3两步，其实若是很熟练的话，可以直接把方程写出来，那也就完事了，没有别的办法，多练多体会就一定能掌握。

问题分析：

爬楼梯（LeetCode 第 70 号问题）
假设你正在爬楼梯。需要 n 阶你才能到达楼顶。

每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？

注意：给定 n 是一个正整数。

我们来分析一下这个问题：

首先，我们想一下爬n阶楼梯和爬n-1或者n-2阶楼梯有没有关系，根据题意，每一次只可以爬1或2，所以这里很容易就想到f(n) = f(n-1)+f(n-2),插一句这其实就是斐波那契数列，我们现在用动态规划解决，就不用递归了，我们假设n的状态为dp[n],那么就可以写出状态转移方程dp[n] = dp[n-1]+dp[n-2]，所谓的状态转移就是从n-1和n-2怎么转移到n的，然后就进行实现就好.

class Solution {
public:
    int climbStairs(int n) {
        vector<int> dp(n+1,0);
        if(n == 1) return 1;
        dp[1] = 1;
        dp[2] = 2;

        for(int i=3;i<=n;i++)
        {
            dp[i] = dp[i-1] + dp[i-2];
        }

        return dp[n];


    }
};

再来看一题：LeetCode 第 120 号问题：三角形最小路径和。
给定一个三角形，找出自顶向下的最小路径和。每一步只能移动到下一行中相邻的结点上。

例如，给定三角形：

[
[2],
[3,4],
[6,5,7],
[4,1,8,3]
]
自顶向下的最小路径和为 11（即，2 + 3 + 5 + 1 = 11）。

说明：

如果你可以只使用 O(n) 的额外空间（n 为三角形的总行数）来解决这个问题，那么你的算法会很加分。
言外之意就是让你用动态规划，这是一种用空间换时间的做法。

在三角中，如果我们从上往下，用dp[i][j]记录下每一个元素的路径最小和，那么这时候的状态转移方程就是
dp[i][j] = min(dp[i-1][j],dp[i-1][j-1])+triangle[i][j],也就是上面两个相邻的较小状态加上当前元素，但是在实现时会出现问题，因为第一列没有更左边的，所以不太好，我么如果把三角形倒过来实现那么状态转移方程就是:
dp[i][j]=min(dp[i+1][j],dp[i+1][j+1])+triangle[i][j]
实现：

class Solution {
public:
    int minimumTotal(vector<vector<int>>& triangle) {
        int n = triangle.size();
        

        vector<vector<int>> dp(n,vector<int>(n,0));
        
        for(int i = 0;i < n;i++)
        {
            dp[n-1][i] = triangle[n-1][i];
        }
        
        
        for(int i=n-2;i >= 0;i--)
        {
            for(int j=0;j<i+1;j++)
            {
               
                dp[i][j] = min(dp[i+1][j],dp[i+1][j+1]) + triangle[i][j];
               
            }
        }


        return dp[0][0];
    }
};

类似问题还有很多：数组子数组的最大和问题，最长公共子串问题，最长公共子序列问题。。。大家可以去练练手，后续有时间我会再写一点动态规划的，一起进步。

总结：

像这种最优问题，如果直接去暴力求解时间复杂度必然很高，如果能够把问题拆分成子问题，并且子问题之间的联系好表示，是用动态规划一定是一个不错的方法，而解决问题的重心就会被转移到，定义问题的状态，然后就是写出子问题怎么转移成要求问题的解，也就是写出状态转移方程剩下的就是一些小细节了。

愿每一个程序员都能被温柔相待