学习动态规划

我最早接触动态规划是在研究生期间的运筹学课堂上，老师讲解题的时候在黑板上一步一步写下各个阶段的所有状态。我感觉这个算法很高明，能将复杂的问题瞬间变得简单，当时学得津津有味。上班后做过几天poj，难免碰到一些动态规划的题，写得是稀里糊涂的，后来忙于工作刷题也就搁置了。最近工作有了空闲，正好趁机学习一下动态规划，并将学习心得记录于此。

0，动态规划

动态规划是一种多阶段决策最优解模型，一般用来求最值问题，多数情况下它可以采用自下而上的递推方式来得出每个子问题的最优解（即最优子结构），进而自然而然地得出原问题的最优解。

这里有几个概念：

• 自下而上：自底向上，先求子问题，再求较大问题，一步一步迭代，最后求得原问题。这是一个由小到大的过程
• 自上而下：自顶向下，类似于递归，先由大到小调用，再由小到大返回
• 多阶段决策：原问题可拆分成多阶段子问题
• 最优子结构：每个子问题的最优解
• 状态转移方程：阶段与阶段之间的转换关系，这是动态规划的核心，也是难点

知道了这些定义及相关概念，依然做不出题怎么办？我也有这些困扰，我觉得难点在于2点：定义状态、找出状态转移方程。下面通过一些例子一起学习。

1，爬楼梯

假设你正在爬楼梯。需要 n 阶你才能到达楼顶。每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？注意：给定 n 是一个正整数。

来源：70. 爬楼梯

解题思路：

定义f(i)为爬到第i个台阶需要的方法数量，

那么爬到第i+1个台阶则有两种方案：1）由第i个台阶爬1个台阶到达；2）由第i-1个台阶爬2个台阶到达；

所以状态转移方程为：f(i) = f(i-2) + f(i-1)

class Solution {
public:
    int climbStairs(int n) {
        vector<int> dp(n+2, 0); // 为了防止下一行赋值异常，所以+2
        dp[0] = 1, dp[1] = 1;
        for (int i = 2; i <= n; i++) {
            dp[i] = dp[i-1] + dp[i-2];
        }
        return dp[n];
    }
};

空间复杂度优化方案，由于f(i)只和f(i-2)、f(i-1)相关，可采用滚动数组的方法，只需定义3个变量，即可将空间复杂度由O(N)降为O(1)。但这里为了学习动态规划，保留O(N)使问题更清晰，后面习题同理。

2，买卖股票

给定一个数组 prices ，它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。

你只能选择 某一天 买入这只股票，并选择在 未来的某一个不同的日子 卖出该股票。设计一个算法来计算你所能获取的最大利润。

返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润，返回 0 。

来源：121. 买卖股票的最佳时机

解题思路：

定义f(i)为price[0, 1, 2, ..., i]中的最小值，min{price[0], price[1], ..., price[i]}

假如第i天卖出股票，那么它的最大利润则是price[i] - f(i-1)。注意：price[i] - f(i)结果一样，但它的逻辑是T+0（当天买当天卖）。

所以最大利润的状态转移方程为：f(i) = price[i] - f(i-1)。

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        // dp[i]:前i+1个元素的最小值
        vector<int> dp = prices;
        int max = 0;
        for (int i = 1; i < prices.size(); i++) {
            dp[i] = std::min(prices[i], dp[i-1]);
            max = std::max(prices[i] - dp[i-1], max);
        }
        return max;
    }
};

另外一个思路：定义f(i)为第i天卖出股票的最大利润，则f(i) = price[i] - min(price[0, 1, 2,..., i-1])，定义一个变量始终记录前i-1个元素的最小值，最后再求f(i)中的最大值。

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        vector<int> dp(prices.size(), 0);
        dp[0] = 0;
        int min = prices[0];
        for (int i = 0; i < prices.size(); i++) {
            if (min > prices[i]) min = prices[i];
            // 当前卖出，之前min时买入则利润最大
            dp[i] = prices[i] - min;
        }
        int max = 0;
        for (int i = 0; i < dp.size(); i++) {
            if (max < dp[i]) max = dp[i];
        }
        return max;
    }
};

3，连续子数组的和

给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。

来源：53. 最大子序和  &&  面试题 16.17. 连续数列  &&  剑指 Offer 42. 连续子数组的最大和

解题思路：

数组中必定存在负数，否则返回整个数组的和即可。

定义f(i)为以nums[i]结尾的子数组的和，当f(i-1)>0时，f(i) = f(i-1) + nums[i]; 否则，f(i) = nums[i]。

二者合一可得状态转移方程：f(i) = max{f(i-1) + nums[i], nums[i]}。

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        vector<int> dp = nums; // dp[i]表示以nums[i]结尾的子数组的和
        for (int i = 1; i < nums.size(); i++) {
            dp[i] = max(dp[i-1] + nums[i], nums[i]);
        }
        return *max_element(dp.begin(), dp.end());
    }
};

或者：

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        vector<int> dp = nums; // dp[i]表示以nums[i]结尾的子数组的和
        for (int i = 1; i < nums.size(); i++) {
            if (dp[i-1] > 0) dp[i] += dp[i-1];
        }
        return *max_element(dp.begin(), dp.end());
    }
};

4，最长递增子序列

给你一个整数数组 nums ，找到其中最长严格递增子序列的长度。

来源：300. 最长递增子序列

解题思路：

定义f(i)为以nums[i]结尾的子序列的最大长度，则f(i) = max{f[k]} + 1，其中k=0,1,2,...,i-1并且nums[k]<nums[i]。

例如，

以7结尾的子序列：

7前面小于7的数字有3个，分别是2,5,3，7可以与他们分别组成子序列，分别是[,,,2,7], [,,,5,7], [,,,3,7]，新的子序列长度分别是2,3,3，7对应下标是5，则dp[5]=3。详细见此文。

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        if (nums.empty()) return 0;
        // dp[i]:以nums[i]结尾的子序列的最大长度
        vector<int> dp(nums.size() + 1, 1);
        for (int i = 1; i < nums.size(); i++) {
            for (int k = 0; k < i; k++) {
                if (nums[k] < nums[i] && dp[k] >= dp[i]) {
                    dp[i] = dp[k] + 1;
                }
            }
        }
        return *max_element(dp.begin(), dp.end());
    }
};

5，最长公共子序列

给定两个字符串 text1 和 text2，返回这两个字符串的最长 公共子序列 的长度。如果不存在 公共子序列 ，返回 0 。

来源：1143. 最长公共子序列

解题思路：

定义L(i,j)为序列a[0:i]和序列b[0:j]最长公共子序列的长度，则有：

 

• L(0,0)=L(i,0)=L(0,j)=0
• ai=bj时，L(i,j) = L(i-1, j-1) + 1
• ai!=bj时，L(i,j) = max{L(i-1,j), L(i, j-1)}

class Solution {
public:
    int longestCommonSubsequence(string text1, string text2) {
        int m = text1.size(), n = text2.size();
        vector<vector<int>> dp(m + 1, vector<int>(n + 1));
        for (int i = 1; i <= m; i++) {
            for (int j = 1; j <= n; j++) {
                if (text1[i-1] == text2[j-1]) {
                    dp[i][j] = dp[i - 1][j - 1] + 1;
                } else {
                    dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);
                }
            }
        }
        return dp[m][n];
    }
};