【LeetCode 热题 100】动态规划 系列

📁 70. 爬楼梯

        状态标识：爬到第i层楼梯时，有多少种方法。

        状态转移方程：dp[i] = dp[i-1] + dp[i-2]，表示从走一步和走两步的方式。

        初始化：dp[1] = 1 , dp[2] = 2。

        返回值：dp[n]，即走到第n层可以有多少种爬法。

class Solution {
public:int climbStairs(int n) {int dp[50] = { 0  , 1 , 2};for(int i = 3 ; i <= n ; ++i){dp[i] = dp[i-1] + dp[i-2];}return dp[n];}
};

📁 118. 杨辉三角

        就是一道找规律的题目，每一列第一个和每一行最后一个初始化为1，其余的为左上方和右上方数之和。

        状态转移方程：dp[i][j] = dp[i-1][j] + dp[i-1][j-1]。

vector<vector<int>> generate(int numRows) {vector<vector<int>> dp(numRows);for(int i = 0 ; i < numRows ; ++i)dp[i].resize(i + 1) , dp[i][i] = 1 , dp[i][0] = 1;for(int i = 2 ; i < numRows ; ++i)for(int j = 1 ; j < i ; ++j)dp[i][j] = dp[i-1][j] + dp[i-1][j-1];return dp;}

📁 198. 打家劫舍

        状态表示：dp[i]表示偷窃到第 i 加时，此时偷取到的最大金额。

        转移方程：dp[i] = max(dp[i-1] , dp[i-2] + num[i-1])

        初始化：dp[0] = nums[1]，第一家是可以直接偷取到的。

        返回值：返回dp[n]，即偷取到最后一家是此时的最大金额。

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

📁 279. 完全平方数

        状态标识：dp[i]表示和为 i 的完全平方数的最小数量。 

        转移方程：dp[i] = min(dp[i] , dp[i - j * j] + 1)。j * j 表示小于i的完全平方数 

        初始化：dp[i] = i，将当前数字更新为最大结果，即最坏结果，表示 i 可以由 i 个 1 组成。

        返回值：返回dp[n]。

        动态规划本身就是一个递推的过程，我们从前往后枚举，当枚举到第i个数的时候，意味着i-1都被枚举完了。因此，当一个数减去一个完全平方数时剩余和一定能在dp数组中找到，并且剩余和已经知道最小完全平方数的最小数量，因此，我们结果只需要在此基础上+1即可。

class Solution {
public:int numSquares(int n) {vector<int> dp(n + 1 , 0);for(int i = 1 ; i <= n ; ++i){dp[i] = i;for(int j = 2 ; j * j <= i ; ++j){dp[i] = min(dp[i] , dp[i-j*j] + 1);}}return dp[n];}
};

📁 322. 零钱兑换

        这道题可以看做是上一题的一种变形。

        状态标识：dp[i]表示金额为 i 的时，需要的最少硬币数量。 

        转移方程：dp[i] = min(dp[i] , dp[i - coin] + 1)。

        初始化：dp[0] = 0，其余将当前数字更新0x3f3f3f3f，表示目前不能通过硬币各个金额组成选择不能组成（方便返回值的处理）

        返回值：返回dp[amoun]。需要注意的是，如果dp[amoun] = 0x3f3f3f3f，需要返回-1。

class Solution {
public:int coinChange(vector<int>& coins, int amount) {vector<int> dp(amount + 1, 0x3f3f3f3f);dp[0] = 0;for(int i = 1 ; i <= amount ; ++i){for(auto coin : coins)if(coin <= i)dp[i] = min(dp[i] , dp[i-coin] + 1);}return dp[amount]==0x3f3f3f3f ? -1 : dp[amount];}
};

📁 139. 单词拆分

        状态表示：以某个字符为结尾的字符串，能否由wordDict中的word拼接形成。为了快速查找字典里面的单词，我们是用哈希系列容器存储单词。

        转移方程：dp[i] = str(j , i)是字典里面的单词 &&  dp[j - 1]。

        初始化：dp[0] = true，表示只有一个字符，并且成功在哈希表中找到。

        返回值：dp[n]，以n为结尾的字符串，能否由wordDict中的word拼接形成。

class Solution {
public:bool wordBreak(string s, vector<string>& wordDict) {int n = s.size();vector<int> dp(n + 1 , false);dp[0] = true;unordered_set<string> hash;for(auto word : wordDict)hash.insert(word);for(int i = 1 ; i <= n ; ++i){for(int j = i; j > 0 ; --j){string tmp = s.substr(j - 1, i - j + 1);if(hash.find(tmp) != hash.end())dp[i] = dp[j - 1];if(dp[i] == true)break;}}return dp[n];}
};

📁 300. 最长递增子序列

        如果想要有一个子序列尽可能的多，那么就要使得子序列中元素相较于前一个元素上升趋势尽可能小，与后一个元素上升趋势尽可能大。通过一个数组dp来维护递增子序列。

        1. 当新来一个元素时，如果大于尾部元素，直接插入；

        2. 如果小于尾部元素，那么之前就一定存在比他的的一个或者多个元素，因此我们将这个新的较小值更新到子序列中第一个比它的的元素中，使得子序列上升趋势变得更小。

        使用二分查找算法，查找子序列中第一个比新来较小值大的的元素，然后更新。

class Solution {
public:int lengthOfLIS(vector<int>& nums) {int n = nums.size();vector<int> ret;ret.push_back(nums[0]);for(int i = 1 ; i < n ; ++i){if(nums[i] > ret.back())ret.push_back(nums[i]);else{int left = 0 , right = ret.size() - 1;while(left < right){int mid = (left + right) >> 1;if(ret[mid] < nums[i])left = mid + 1;    elseright = mid;}ret[left] = nums[i];}}return ret.size();}
};

📁 152. 乘积最大子数组

        遍历数组，每次遍历时，记录乘积最大值，更新结果。问题是乘积最大值怎么更新？

        当一个新元素x到来时，与之前连续子数组乘积最大值maxS进行比较 max( x , maxS)。

        1. 如果 x 是正数，且maxS也是正数，那么会得到一个更大的正数。

        2. 如果 x 是正数，maxS是负数，那么会得到一个更小的数值。

        3. 如果 x 是负数，maxS是正数，那么会得到一个更小的数值。

         4. 如果 x 是负数，maxS是负数，那么会得到一个更大的数值。

        但如果我们记录一个较小值minS，那么 x 如果负数，minS也是负数，就会得到一个更大的值。

        即，如果x是正数，必须有一个最大值相乘才能得到更大值；如果x是负数，必须和一个最小值相乘才能得到一个更大值。

        核心：负数 x 大=小；负数 x 小=大；正数 x 大=大；正数 x 小=小

class Solution {
public:int maxProduct(vector<int>& nums) {int ans = nums[0] , maxI = nums[0] , minI = nums[0];int n = nums.size();for(int i = 1 ; i < n ; ++i){int tmp = maxI;/*nums[i] * tmp: 如果nums[i]是正数, 得到更大值nums[i] * minI: 如果nums[i]是负数, 得到更大值*/maxI = max(max(nums[i] , nums[i] * tmp) , nums[i] * minI);/*nums[i] * minI: 如果nums[i]是正数, 得到更小值nums[i] * tmp: 如果nums[i]是负数, 得到更小值*/minI = min(min(nums[i] , nums[i] * minI) , nums[i] * tmp);ans = max(ans , maxI);}return ans;}
};

📁 416. 分割等和子集

        就是一道简单的01背包问题。首先判断个数组总和是否为偶数，如果是奇数直接返回false，因为不可能将数组分割成元素和相等的两个子集；如果sum是偶数，令target = sum / 2。需要判断从数组中能否选出一些数，使得这些数之和=target。

        状态标识：dp[i][j]: 前i个元素中能否恰好选出 总和为 j 的子集

        转移方程：dp[i][j] = (不选第i件，dp[i-1][j]) or (选第i件 dp[i-1][j-nums[i]])

        返回值：dp[n][target]。

        此外，采用滚动数组进行优化，使得只能一维数组就可以完成上述操作，只不是从前往后遍历改成往后往前遍历。

class Solution {
public:bool canPartition(vector<int>& nums) {int sum = 0;for(auto e : nums)sum += e;if(sum % 2 != 0)return false;int n = nums.size();int target = sum / 2;vector<bool> dp(target + 1 , false);dp[0] = true;for(int i = 1 ; i <= n ; ++i){for(int j = target ; j >= nums[i-1] ; --j)dp[j] = dp[j] || dp[j- nums[i-1]];}return dp[target];}
};

📁 32. 最长有效括号

    状态表示: dp[i]表示 以s[i]为结尾并且包含s[i]的最长有效括号。

    状态转移方程:

        1. s[i] =='(' 无法组成有效括号 dp[i] = 0;

        2. s[i] ==')' 取决于之前的有效括号

         情况1: s[i-1] == '('

            dp[i] = dp[i-2] + 2;

         情况2:  s[i-1] == ')'

            这里如果想要包含s[i]组成有效括号的字符串，

            必须满足 ((...)) 这种形式 , 其中...是未知个数的有效括号子串。

                    |

                    v

            即 s[i - dp[i-1] - 1] == '('

            所以, dp[i] = dp[i-1] + dp[i - dp[i-1] - 2 ] + 2;

    初始化:

        dp[0] = 0 一个字符不能构成有效括号

class Solution {
public:int longestValidParentheses(string s) {int n = s.size();int ans = 0;vector<int> dp(n + 1 , 0);for(int i = 1 ; i <= n ; ++i){if(s[i] == ')'){if(s[i-1] == '(')dp[i] = (i - 2 >= 0 ? dp[i-2] : 0) + 2;else if(i - dp[i-1] - 1 >= 0 && s[i - dp[i-1] - 1] == '(')dp[i] = dp[i - 1] + 2 + (i - dp[i-1] - 2 >= 0 ? dp[i - dp[i-1] - 2] : 0);}ans = max(ans , dp[i]);}return ans;}
};