代码随想录-笔记-其九

继续我们之前未完成的动态规划的题目：

139. 单词拆分 - 力扣（LeetCode）

给你一个字符串 s 和一个字符串列表 wordDict 作为字典。如果可以利用字典中出现的一个或多个单词拼接出 s 则返回 true。

注意：不要求字典中出现的单词全部都使用，并且字典中的单词可以重复使用。

class Solution {
public:bool wordBreak(string s, vector<string>& wordDict) {unordered_set<string> set(wordDict.begin(), wordDict.end());vector<bool> dp(s.size() + 1);dp[0] = true;for (int i = 1; i <= s.size(); ++i) {for (int j = 0; j < i; ++j) {if (dp[j] && set.contains(s.substr(j, i - j))) {dp[i] = true;break; }}}return dp[s.size()];}
};

我们可以将其转化为完全背包问题：能否用一个或多个物品（字符串）填满需求的背包（字符串）。用一个额外的哈希表来检查是否满足需求，并且要注意序号的统一性：因为dp[0]已经被直接定义为true了，所以我们序号从1开始。

56. 携带矿石资源（第八期模拟笔试） (kamacoder.com)

你是一名宇航员，即将前往一个遥远的行星。在这个行星上，有许多不同类型的矿石资源，每种矿石都有不同的重要性和价值。你需要选择哪些矿石带回地球，但你的宇航舱有一定的容量限制。

给定一个宇航舱，最大容量为 C。现在有 N 种不同类型的矿石，每种矿石有一个重量 w[i]，一个价值 v[i]，以及最多 k[i] 个可用。不同类型的矿石在地球上的市场价值不同。你需要计算如何在不超过宇航舱容量的情况下，最大化你所能获取的总价值。

#include <iostream>
#include <vector>
using namespace std;
int main(){int badgetweights,n;cin>>badgetweights>>n;vector<int> weights(n),values(n),nums(n);for(int i=0;i<n;++i){cin>>weights[i];}for(int i=0;i<n;++i){cin>>values[i];}for(int i=0;i<n;++i){cin>>nums[i];}vector<int> dp(badgetweights+1,0);for(int i=0;i<n;++i){for(int j=badgetweights;j>=weights[i];--j){for(int k=0;k<=nums[i]&&j-k*weights[i]>=0;++k){dp[j]=max(dp[j],dp[j-k*weights[i]]+k*values[i]);}}}cout<<dp[badgetweights]<<endl;return 0;
}

这个题则是属于另一种背包：多重背包，简单地说，他就是升级版的0-1背包：0-1背包是每个物体只能选择一次，而多重背包是一个物体可以选择一定的次数，在代码里的差异也显而易见：我们在基础的0-1背包的基础上需要多加一层使用次数的遍历即可。

198. 打家劫舍 - 力扣（LeetCode）

你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。

给定一个代表每个房屋存放金额的非负整数数组，计算你 不触动警报装置的情况下 ，一夜之内能够偷窃到的最高金额。

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

打劫题好像也是经典的动态规划题，我们从这个非常简单的例子开始。

213. 打家劫舍 II - 力扣（LeetCode）

你是一个专业的小偷，计划偷窃沿街的房屋，每间房内都藏有一定的现金。这个地方所有的房屋都 围成一圈 ，这意味着第一个房屋和最后一个房屋是紧挨着的。同时，相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警 。

给定一个代表每个房屋存放金额的非负整数数组，计算你 在不触动警报装置的情况下 ，今晚能够偷窃到的最高金额。

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

第一个变种：屋子变成环，处于不能同时偷相邻的屋子的特性，我们只需要一个不考虑首部一个不考虑尾部即可。

337. 打家劫舍 III - 力扣（LeetCode）

小偷又发现了一个新的可行窃的地区。这个地区只有一个入口，我们称之为 root 。

除了 root 之外，每栋房子有且只有一个“父“房子与之相连。一番侦察之后，聪明的小偷意识到“这个地方的所有房屋的排列类似于一棵二叉树”。如果 两个直接相连的房子在同一天晚上被打劫 ，房屋将自动报警。

给定二叉树的 root 。返回 在不触动警报的情况下 ，小偷能够盗取的最高金额。

/*** Definition for a binary tree node.* struct TreeNode {*     int val;*     TreeNode *left;*     TreeNode *right;*     TreeNode() : val(0), left(nullptr), right(nullptr) {}*     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}*     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}* };*/
class Solution {
public:int rob(TreeNode* root) {if(!root)return 0;vector<int> res=robTree(root);return max(res[0],res[1]);}vector<int> robTree(TreeNode* cur){if(!cur)return {0,0};vector<int> left=robTree(cur->left);vector<int> right=robTree(cur->right);int val1=cur->val+left[0]+right[0];int val2=max(left[0],left[1])+max(right[0],right[1]);return {val2,val1};}
};

第二个变种：屋子变成了树形结构，那这下不得不同时考虑左子树和右子树了。

121. 买卖股票的最佳时机 - 力扣（LeetCode）

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

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

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

class Solution {
public:int maxProfit(vector<int>& prices) {int low=INT_MAX,res=INT_MIN;for(int price:prices){low=min(low,price);res=max(res,price-low);}return res;}
};

现在该炒股了，说实话，这个题用贪心是最简单的。

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

但如果非要用动态规划的话，也不是不行：我们用二维的dp数组，其中行表示不同的天数列表示是否持有股票的状态，这个题的状态转移方程会比较难以理解，但主要的区别就在于是否持有股票以及是否购入/卖出股票。

122. 买卖股票的最佳时机 II - 力扣（LeetCode）

给你一个整数数组 prices ，其中 prices[i] 表示某支股票第 i 天的价格。

在每一天，你可以决定是否购买和/或出售股票。你在任何时候最多只能持有一股股票。你也可以先购买，然后在 同一天 出售。

返回 你能获得的最大利润 。

class Solution {
public:int maxProfit(vector<int>& prices) {int res=0;for(int i=1;i<prices.size();++i){res=max(res,res+prices[i]-prices[i-1]);}return res;}
};

同样可以先用贪心算法来做。

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

第二个炒股的题与第一个的区别在于第二次炒股时可以反复买入和卖出，所以我们需要多记录一个之前操作的收益。

123. 买卖股票的最佳时机 III - 力扣（LeetCode）

给定一个数组，它的第 i 个元素是一支给定的股票在第 i 天的价格。

设计一个算法来计算你所能获取的最大利润。你最多可以完成两笔交易。

注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。

class Solution {
public:int maxProfit(vector<int>& prices) {int n=prices.size();if(n==0)return 0;vector<vector<int>> dp(n+1,vector<int>(5,0));dp[0][1]=-prices[0];dp[0][3]=-prices[0];for(int i=1;i<n;++i){dp[i][0]=dp[i-1][0];dp[i][1]=max(dp[i-1][1],dp[i-1][0]-prices[i]);dp[i][2]=max(dp[i-1][2],dp[i-1][1]+prices[i]);dp[i][3]=max(dp[i-1][3],dp[i-1][2]-prices[i]);dp[i][4]=max(dp[i-1][4],dp[i-1][3]+prices[i]);}return dp[n-1][4];}
};

如果是两笔交易，那么每天要考虑的状态就是五种了：无操作，第一次购买，第一次卖出，第二次购买，第二次卖出，其他的逻辑流程本质上与其他的股票题并无差异。

188. 买卖股票的最佳时机 IV - 力扣（LeetCode）

给你一个整数数组 prices 和一个整数 k ，其中 prices[i] 是某支给定的股票在第 i 天的价格。

设计一个算法来计算你所能获取的最大利润。你最多可以完成 k 笔交易。也就是说，你最多可以买 k 次，卖 k 次。

注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。

class Solution {
public:int maxProfit(int k, vector<int>& prices) {if (prices.size() == 0) return 0;vector<vector<int>> dp(prices.size(), vector<int>(2 * k + 1, 0));for (int j = 1; j < 2 * k; j += 2) {dp[0][j] = -prices[0];}for (int i = 1;i < prices.size(); i++) {for (int j = 0; j < 2 * k - 1; j += 2) {dp[i][j + 1] = max(dp[i - 1][j + 1], dp[i - 1][j] - prices[i]);dp[i][j + 2] = max(dp[i - 1][j + 2], dp[i - 1][j + 1] + prices[i]);}}return dp[prices.size() - 1][2 * k];}
};

第四次炒股是第三次的升级版，这次我们不再是具体的一次两次，而是k次，那其实本质上与我们的两次的扩展一样，我们需要将i为奇数时视作买入，偶数时视为卖出，然后套一层for循环即可。

309. 买卖股票的最佳时机含冷冻期 - 力扣（LeetCode）

给定一个整数数组prices，其中第 prices[i] 表示第 i 天的股票价格。

设计一个算法计算出最大利润。在满足以下约束条件下，你可以尽可能地完成更多的交易（多次买卖一支股票）:

卖出股票后，你无法在第二天买入股票 (即冷冻期为 1 天)。

注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。

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

714. 买卖股票的最佳时机含手续费 - 力扣（LeetCode）

给定一个整数数组 prices，其中 prices[i]表示第 i 天的股票价格；整数 fee 代表了交易股票的手续费用。

你可以无限次地完成交易，但是你每笔交易都需要付手续费。如果你已经购买了一个股票，在卖出它之前你就不能再继续购买股票了。

返回获得利润的最大值。

注意：这里的一笔交易指买入持有并卖出股票的整个过程，每笔交易你只需要为支付一次手续费。

class Solution {
public:int maxProfit(vector<int>& prices, int fee) {int n = prices.size();vector<vector<int>> dp(n, vector<int>(2, 0));dp[0][0] -= prices[0]; // 持股票for (int i = 1; i < n; i++) {dp[i][0] = max(dp[i - 1][0], dp[i - 1][1] - prices[i]);dp[i][1] = max(dp[i - 1][1], dp[i - 1][0] + prices[i] - fee);}return max(dp[n - 1][0], dp[n - 1][1]);}
};

300. 最长递增子序列 - 力扣（LeetCode）

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

子序列 是由数组派生而来的序列，删除（或不删除）数组中的元素而不改变其余元素的顺序。例如，[3,6,2,7] 是数组 [0,3,1,6,2,2,7] 的子序列。

class Solution {
public:int lengthOfLIS(vector<int>& nums) {vector<int> dp(nums.size()+1,1);for(int i=1;i<nums.size();++i){for(int j=0;j<i;++j){if(nums[i]>nums[j]){dp[i]=max(dp[i],dp[j]+1);}}}return *max_element(dp.begin(),dp.end());}
};

接下来是子序列相关问题：子序列即可以删除一定中间元素的子数组（只要保证顺序不变即可），大多的子序列问题会要求我们去求最长长度，所以我们dp数组的含义就是长度为i的数组的最长递增子序列。

674. 最长连续递增序列 - 力扣（LeetCode）

给定一个未经排序的整数数组，找到最长且 连续递增的子序列，并返回该序列的长度。

连续递增的子序列 可以由两个下标 l 和 r（l < r）确定，如果对于每个 l <= i < r，都有 nums[i] < nums[i + 1] ，那么子序列 [nums[l], nums[l + 1], ..., nums[r - 1], nums[r]] 就是连续递增子序列。

class Solution {
public:int findLengthOfLCIS(vector<int>& nums) {vector<int> dp(nums.size()+1,1);for(int i=1;i<nums.size();++i){if(nums[i]>nums[i-1]){dp[i]=max(dp[i],dp[i-1]+1);}}return *max_element(dp.begin(), dp.end());}
};

这个题比起上一个题来说递推公式其实更简单：我们只需要比较当前序号的数组的值与上一个序号的值即可。

718. 最长重复子数组 - 力扣（LeetCode）

给两个整数数组 nums1 和 nums2 ，返回 两个数组中 公共的 、长度最长的子数组的长度 。

class Solution {
public:int findLength(vector<int>& nums1, vector<int>& nums2) {int m=nums1.size(),n=nums2.size(),res=0;vector<vector<int>> dp(m+1,vector<int>(n+1,0));for(int i=1;i<=m;++i){for(int j=1;j<=n;++j){if(nums1[i-1]==nums2[j-1]){dp[i][j]=dp[i-1][j-1]+1;}if(dp[i][j]>res){res=dp[i][j];}}}return res;}
};

1143. 最长公共子序列 - 力扣（LeetCode）

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

一个字符串的 子序列 是指这样一个新的字符串：它是由原字符串在不改变字符的相对顺序的情况下删除某些字符（也可以不删除任何字符）后组成的新字符串。

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,0));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];}
};

这里我把最长重复子数组和最长公共子序列放在一起，是因为这两个题的大体代码看起来一致，只有返回的值不同，但其实本质上二者差距很大。比如dp数组的含义，以及最后我们需要返回的值。

1035. 不相交的线 - 力扣（LeetCode）

在两条独立的水平线上按给定的顺序写下 nums1 和 nums2 中的整数。

现在，可以绘制一些连接两个数字 nums1[i] 和 nums2[j] 的直线，这些直线需要同时满足：

nums1[i] == nums2[j]
且绘制的直线不与任何其他连线（非水平线）相交。

请注意，连线即使在端点也不能相交：每个数字只能属于一条连线。

以这种方法绘制线条，并返回可以绘制的最大连线数。

class Solution {
public:int maxUncrossedLines(vector<int>& nums1, vector<int>& nums2) {int m=nums1.size(),n=nums2.size();vector<vector<int>> dp(m+1,vector<int>(n+1,0));for(int i=1;i<=m;++i){for(int j=1;j<=n;++j){if(nums1[i-1]==nums2[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];}
};

这个题咋一看似乎非常复杂，但其实本质上依然是一个求最长公共子序列的问题。(可以看看这个题的解析，光说比较抽象)

53. 最大子数组和 - 力扣（LeetCode）

给你一个整数数组 nums ，请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和，子数组是数组中的一个连续部分。

class Solution {
public:int maxSubArray(vector<int>& nums) {int cursum=0,res=nums[0];for(int num:nums){cursum=max(cursum+num,num);res=max(res,cursum);}return res;}
};

首先先贴一个贪心的做法，非常的直观，我们不断维护一个最大的子数组和即可。

class Solution {
public:int maxSubArray(vector<int>& nums) {if(nums.size()==0)return 0;vector<int> dp(nums.size());dp[0]=nums[0];for(int i=1;i<nums.size();++i){dp[i]=max(nums[i],dp[i-1]+nums[i]);}return *max_element(dp.begin(), dp.end());}
};

这个动态规划的做法其实本质上也是贪心的思路，只是用一个更容易看懂的写法罢了。

392. 判断子序列 - 力扣（LeetCode）

给定字符串 s 和 t ，判断 s 是否为 t 的子序列。

字符串的一个子序列是原始字符串删除一些（也可以不删除）字符而不改变剩余字符相对位置形成的新字符串。（例如，"ace"是"abcde"的一个子序列，而"aec"不是）。

class Solution {
public:bool isSubsequence(string s, string t) {vector<vector<int>> dp(s.size()+1,vector<int>(t.size()+1,0));for(int i=1;i<=s.size();++i){for(int j=1;j<=t.size();++j){if(s[i-1]==t[j-1])dp[i][j]=dp[i-1][j-1]+1;else dp[i][j]=dp[i][j-1];}}return dp[s.size()][t.size()]==s.size();}
};

这个题的难点在于else的情况下我们要去保留s的字符而去删除t的字符，我们从删除的角度来理解就方便得多。

115. 不同的子序列 - 力扣（LeetCode）

给你两个字符串 s 和 t ，统计并返回在 s 的 子序列 中 t 出现的个数。

class Solution {
public:int numDistinct(string s, string t) {vector<vector<uint64_t>> dp(s.size() + 1, vector<uint64_t>(t.size() + 1));for (int i = 0; i < s.size(); i++) dp[i][0] = 1;for (int j = 1; j < t.size(); j++) dp[0][j] = 0;for (int i = 1; i <= s.size(); i++) {for (int j = 1; j <= t.size(); j++) {if (s[i - 1] == t[j - 1]) {dp[i][j] = dp[i - 1][j - 1] + dp[i - 1][j];} else {dp[i][j] = dp[i - 1][j];}}}return dp[s.size()][t.size()];}
};

72. 编辑距离 - 力扣（LeetCode）

给你两个单词 word1 和 word2， 请返回将 word1 转换成 word2 所使用的最少操作数 。

你可以对一个单词进行如下三种操作：

插入一个字符
删除一个字符
替换一个字符

class Solution {
public:int minDistance(string word1, string word2) {vector<vector<int>> dp(word1.size()+1,vector<int>(word2.size()+1));for(int i=0;i<=word1.size();++i){dp[i][0]=i;}for(int j=0;j<=word2.size();++j){dp[0][j]=j;}for(int i=1;i<=word1.size();++i){for(int j=1;j<=word2.size();++j){if(word1[i-1]==word2[j-1]){dp[i][j]=dp[i-1][j-1];}else{dp[i][j]=min({dp[i-1][j],dp[i][j-1],dp[i-1][j-1]})+1;}}}return dp[word1.size()][word2.size()];}
};

583. 两个字符串的删除操作 - 力扣（LeetCode）

给定两个单词 word1 和 word2 ，返回使得 word1 和 word2 相同所需的最小步数。

每步可以删除任意一个字符串中的一个字符

class Solution {
public:int minDistance(string word1, string word2) {vector<vector<int>> dp(word1.size() + 1, vector<int>(word2.size() + 1));for (int i = 0; i <= word1.size(); i++) dp[i][0] = i;for (int j = 0; j <= word2.size(); j++) dp[0][j] = j;for (int i = 1; i <= word1.size(); i++) {for (int j = 1; j <= word2.size(); j++) {if (word1[i - 1] == word2[j - 1]) {dp[i][j] = dp[i - 1][j - 1];} else {dp[i][j] = min(dp[i - 1][j] + 1, dp[i][j - 1] + 1);}}}return dp[word1.size()][word2.size()];}
};

647. 回文子串 - 力扣（LeetCode）

给你一个字符串 s ，请你统计并返回这个字符串中 回文子串 的数目。

回文字符串 是正着读和倒过来读一样的字符串。

子字符串 是字符串中的由连续字符组成的一个序列。

class Solution {
public:int countSubstrings(string s) {vector<vector<bool>> dp(s.size(),vector<bool>(s.size(),false));int res=0;for(int i=s.size()-1;i>=0;--i){for(int j=i;j<s.size();++j){if(s[i]==s[j]){if(j-i<=1){res++;dp[i][j]=true;}else if(dp[i+1][j-1]){res++;dp[i][j]=true;}}}}return res;}
};

516. 最长回文子序列 - 力扣（LeetCode）

给你一个字符串 s ，找出其中最长的回文子序列，并返回该序列的长度。

子序列定义为：不改变剩余字符顺序的情况下，删除某些字符或者不删除任何字符形成的一个序列。

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