力扣刷题之动态规划
动态规划,简称DP,如果某问题有很多重叠子问题,使用动态规划是最有效的,动态规划中每一个状态一定是由上一个状态推导出来的,这一点区别于贪心,贪心没有状态推导,而是从局部直接选最优
动态规划解题五部曲:
- 确定dp数组以及下标的含义
- 确定递推公式
- dp数组如何初始化
- 确定遍历顺序
- 举例推导dp数组
509.斐波那契数列
class Solution {
public:
int fib(int n) {
if(n<2) return n;
int dp[2];
dp[0]=0;
dp[1]=1;
for(int i=2;i<=n;i++){
int sum=dp[0]+dp[1];
dp[0]=dp[1];
dp[1]=sum;
}
return dp[1];
}
};
O(n),O(1)
用递归的话,时间复杂度太高
70.爬楼梯
思路:爬到第一层楼梯有一种方法,爬到第二层楼梯有两种方法,从第一层楼梯再跨两步就到第三层,第二层楼梯再跨一步就到第三层,所以第三层楼梯的状态可以由第二层楼梯和到第一层楼梯状态推导出来,那么就可以想到动态规划
动规五部曲:
class Solution {
public:
int climbStairs(int n) {
if(n<2)return n;
int dp[3];
dp[1]=1;
dp[2]=2;
for(int i=3;i<=n;i++){
int sum=dp[1]+dp[2];
dp[1]=dp[2];
dp[2]=sum;
}
return dp[2];
}
};
和斐波那契数列很类似
O(n),O(1)
//背包法,求组合数
class Solution {
public:
int climbStairs(int n) {
vector<int> dp(n + 1, 0);
dp[0] = 1;
for (int i = 1; i <= n; i++) { // 遍历背包
for (int j = 1; j <= 2; j++) { // 遍历物品
if (i - j >= 0) dp[i] += dp[i - j];
}
}
return dp[n];
}
};
746.使用最小花费爬楼梯
思路:dp[i]的定义:到达第i个台阶所花费的最少体力为dp[i]
有两个途径得到dp[i],一个是dp[i-1],一个是dp[i-2],选其中最小的,所以dp[i] = min(dp[i - 1], dp[i - 2]) + cost[i]
class Solution {
public:
int minCostClimbingStairs(vector<int>& cost) {
int dp0=cost[0];
int dp1=cost[1];
for(int i=2;i<cost.size();i++){
int dpi=min(dp0,dp1)+cost[i];
dp0=dp1;
dp1=dpi;
}
return min(dp0,dp1);
}
};
62.不同路径
//二维dp数组
class Solution {
public:
int uniquePaths(int m, int n) {
vector<vector<int>> dp(m,vector<int>(n));
for(int i=0;i<m;i++)dp[i][0]=1;
for(int j=0;j<n;j++)dp[0][j]=1;
for(int i=1;i<m;i++){
for(int j=1;j<n;j++){
dp[i][j]=dp[i-1][j]+dp[i][j-1];
}
}
return dp[m-1][n-1];
}
};
//数论法
class Solution {
public:
int uniquePaths(int m, int n) {
long long ans = 1;
for (int x = n, y = 1; y < m; ++x, ++y) {
ans = ans * x / y;
}
return ans;
}
};
63.不同路径II
class Solution {
public:
int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {
int m=obstacleGrid.size();
int n=obstacleGrid[0].size();
vector<vector<int>>dp(m,vector<int>(n));
for(int i=0;i<m&&obstacleGrid[i][0]==0;i++)dp[i][0]=1;
for(int j=0;j<n&&obstacleGrid[0][j]==0;j++)dp[0][j]=1;
for(int i=1;i<m;i++){
for(int j=1;j<n;j++){
if(obstacleGrid[i][j]==1)continue;
dp[i][j]=dp[i-1][j]+dp[i][j-1];
}
}
return dp[m-1][n-1];
}
};
343.整数拆分
class Solution {
public:
int integerBreak(int n) {
vector<int> dp(n+1);
dp[2]=1;
for(int i=3;i<=n;i++){
for(int j=1;j<i-1;j++){
dp[i]=max(dp[i],max((i-j)*j,dp[i-j]*j));
}
}
return dp[n];
}
};
96.不同的二叉搜索树
class Solution {
public:
int numTrees(int n) {
vector<int> dp(n+1,0);
dp[0]=1;
dp[1]=1;
for(int i=2;i<=n;++i){
for(int j=1;j<=i;++j){
dp[i]+=dp[j-1]*dp[i-j];
}
}
return dp[n];
}
};
01背包问题
416.分割等和子集
class Solution {
public:
bool canPartition(vector<int>& nums) {
int sum=0;
vector<int> dp(10001,0);
for(int i=0;i<nums.size();i++){
sum+=nums[i];
}
if(sum%2==1)return false;
int target=sum/2;
for(int i=0;i<nums.size();i++){
for(int j=target;j>=nums[i];j--){
dp[j]=max(dp[j],dp[j-nums[i]]+nums[i]);
}
}
if(dp[target]==target)return true;
return false;
}
};
1049.最后一块石头的重量II
思路:任意选i块石头,使得他们的重量趋近于总重量的一半,这样和另一半抵消的差值就是最小的
class Solution {
public:
int lastStoneWeightII(vector<int>& stones) {
vector<int> dp(15001,0);
int sum=0;
for(int i=0;i<stones.size();i++)sum+=stones[i];
int target=sum/2;
for(int i=0;i<stones.size();i++){
for(int j=target;j>=stones[i];j--){
dp[j]=max(dp[j],dp[j-stones[i]]+stones[i]);
}
}
return sum-dp[target]-dp[target];
}
};
494.目标和
背包解决排列组合问题
class Solution {
public:
int findTargetSumWays(vector<int>& nums, int target) {
int sum=0;
for(int i=0;i<nums.size();i++)sum+=nums[i];
if(target>sum)return 0;
if((target+sum)%2==1)return 0;
int bagSize=(target+sum)/2;
vector<int> dp(abs(bagSize)+1,0);
dp[0]=1;
for(int i=0;i<nums.size();i++){
for(int j=bagSize;j>=nums[i];j--){
dp[j]+=dp[j-nums[i]];
}
}
return dp[abs(bagSize)];
}
};
474.一和零
class Solution {
public:
int findMaxForm(vector<string>& strs, int m, int n) {
vector<vector<int>>dp(m+1,vector<int>(n+1,0));
for(string str:strs){
int oneNum=0,zeroNum=0;
for(char c:str){
if(c=='0')zeroNum++;
else oneNum++;
}
for(int i=m;i>=zeroNum;i--){
for(int j=n;j>=oneNum;j--){
dp[i][j]=max(dp[i][j],dp[i-zeroNum][j-oneNum]+1);
}
}
}
return dp[m][n];
}
};
完全背包问题
完全背包和01背包唯一不同的地方就是,每种物品有无限件
518.零钱兑换II(可以照葫芦画瓢写了)
class Solution {
public:
int change(int amount, vector<int>& coins) {
vector<int> dp(amount+1,0);
dp[0]=1;//这步一开始忘记了
for(int i=0;i<coins.size();i++){
for(int j=coins[i];j<=amount;j++){
dp[j]+=dp[j-coins[i]];
}
}
return dp[amount];
}
};
377.组合总数IV
class Solution {
public:
int combinationSum4(vector<int>& nums, int target) {
vector<int> dp(target+1,0);
dp[0]=1;
for(int j=0;j<=target;j++){
for(int i=0;i<nums.size();i++){
if(j-nums[i]>=0&&dp[j]<INT_MAX-dp[j-nums[i]])
dp[j]+=dp[j-nums[i]];
}
}
return dp[target];
}
};
322.零钱兑换
class Solution {
public:
int coinChange(vector<int>& coins, int amount) {
vector<int> dp(amount+1,INT_MAX);
dp[0]=0;
for(int i=0;i<coins.size();i++){
for(int j=coins[i];j<=amount;j++){
if(dp[j-coins[i]]!=INT_MAX){
dp[j]=min(dp[j-coins[i]]+1,dp[j]);
}
}
}
if(dp[amount]==INT_MAX)return -1;
return dp[amount];
}
};
279.完全平方数
class Solution {
public:
int numSquares(int n) {
vector<int> dp(n+1,INT_MAX);
dp[0]=0;
dp[1]=1;
for(int i=1;i*i<=n;i++){
for(int j=1;j<=n;j++){
if(j-i*i>=0)
dp[j]=min(dp[j-i*i]+1,dp[j]);
}
}
return dp[n];
}
};
139.单词拆分
引发思考:如果目标是个字符串应该怎么处理?
如何用set+find找一个单词是否存在在容器中?
如何用substr()函数截取长字符串中的短字符串
public:
bool wordBreak(string s, vector<string>& wordDict) {
unordered_set<string> wordSet(wordDict.begin(),wordDict.end());
vector<bool> dp(s.size()+1,false);
dp[0]=true;
for(int i=1;i<=s.size();i++){
for(int j=0;j<i;j++){
string word=s.substr(j,i-j);
if(wordSet.find(word)!=wordSet.end()&&dp[j]){
dp[i]=true;
}
}
}
return dp[s.size()];
}
};
多重背包
和01背包有点像,每件物品最多有M件可用,把M件摊开,其实就是一个01背包问题了
背包问题总结
遍历顺序:
01背包
- 二维dp数组:先遍历物品或者先遍历背包都可以,第二层for循环是从小到大遍历
- 一维dp数组:只能先遍历物品再遍历背包,且第二层for循环是从大到小遍历
完全背包:
一维dp数组:先遍历物品或者先遍历背包都可以,且第二层for循环是从小到大遍历
- 如果求组合数就应该外层for循环遍历物品,内层for循环遍历背包;
- 求排列数就应该外层for循环遍历背包,内层for循环遍历物品;
- 求最小数的话,两层for循环的先后顺序就无所谓了
打家劫舍
198.打家劫舍
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());
dp[0]=nums[0];
dp[1]=max(nums[0],nums[1]);
for(int i=2;i<nums.size();i++){
dp[i]=max(dp[i-2]+nums[i],dp[i-1]);
}
return dp[nums.size()-1];
}
};
213.打家劫舍II
思路就是把环拆分成不包含环的情况
class Solution {
public:
int rob(vector<int>& nums) {
if(nums.size()==0)return 0;
if(nums.size()==1)return nums[0];
int result1=robRange(nums,0,nums.size()-2);
int result2=robRange(nums,1,nums.size()-1);
return max(result1,result2);
}
int robRange(vector<int>& nums,int start,int end){
if(end==start)return nums[start];
vector<int> dp(nums.size());
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-2]+nums[i],dp[i-1]);
}
return dp[end];
}
};
337.打家劫舍III(好难呜呜)
树形dp入门题,所谓树形dp就是在树上进行递归公式的推导
/**
* 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) {
vector<int> result=robTree(root);
return max(result[0],result[1]);
}
vector<int> robTree(TreeNode*cur){
if(cur==NULL)return vector<int>{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.买卖股票的最佳时机(只买卖一次)
class Solution {
public:
int maxProfit(vector<int>& prices) {
int len=prices.size();
if(len==0)return 0;
vector<vector<int>> dp(len,vector<int>(2));
dp[0][0]-=prices[0];
dp[0][1]=0;
for(int i=1;i<len;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[len-1][1];
}
};
法二:max(今天的价格-今天之前的最小值)
class Solution {
public:
int maxProfit(vector<int>& prices) {
if(prices.size() <= 1)
return 0;
int mmin = prices[0], mmax = 0;
for(int i = 1; i < prices.size(); i++) {
mmax = max(mmax, prices[i] - mmin);
mmin = min(mmin, prices[i]);
}
return mmax;
}
};
122.买卖股票的最佳时机II(可以买卖多次)
class Solution {
public:
int maxProfit(vector<int>& prices) {
int len=prices.size();
if(len==0)return 0;
vector<vector<int>> dp(len,vector<int>(2));
dp[0][0]-=prices[0];
dp[0][1]=0;
for(int i=1;i<len;i++){
dp[i][0]=max(dp[i-1][0],dp[i-1][1]-prices[i]);
dp[i][1]=max(dp[i-1][1],prices[i]+dp[i-1][0]);
}
return dp[len-1][1];
}
};
123.买卖股票的最佳时机III(最多买卖两次)
class Solution {
public:
int maxProfit(vector<int>& prices) {
if(prices.size()==0)return 0;
vector<vector<int>>dp(prices.size(),vector<int>(5,0));
dp[0][1]=-prices[0];
dp[0][3]=-prices[0];
for(int i=1;i<prices.size();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[prices.size()-1][4];
}
};
188、买卖股票的最佳时机IV
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];
}
};
309.最佳买卖股票时机含冷冻期(买卖多次,卖出有一天冷冻期)(好难哦)
class Solution {
public:
int maxProfit(vector<int>& prices) {
int n=prices.size();
if(n==0) return 0;
vector<vector<int>> dp(n,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],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][3],max(dp[n-1][2],dp[n-1][1]));
}
};
714.买卖股票的最佳时机含手续费(买卖多次,买卖一次有一次手续费)
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]);//注意这里与买卖股票II的不同,因为多了手续费,所以最大获益不一定在卖出的时候了
}
};
子序列问题
300.最长增长子序列
class Solution {
public:
int lengthOfLIS(vector<int>& nums) {
if(nums.size()<=1)return nums.size();
vector<int> dp(nums.size(),1);
int result=0;
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);
}
if(dp[i]>result)result=dp[i];
}
return result;
}
};
674.最长连续递增序列
class Solution {
public:
int findLengthOfLCIS(vector<int>& nums) {
if(nums.size()==0)return 0;
int result=1;
vector<int> dp(nums.size(),1);
for(int i=0;i<nums.size()-1;i++){
if(nums[i+1]>nums[i]){
dp[i+1]=dp[i]+1;
}
if(dp[i+1]>result)result=dp[i+1];
}
return result;
}
};
718.最长重复子数组
public:
int findLength(vector<int>& nums1, vector<int>& nums2) {
vector<vector<int>> dp(nums1.size()+1,vector<int>(nums2.size()+1,0));
int result=0;
for(int i=1;i<=nums1.size();i++){
for(int j=1;j<=nums2.size();j++){
if(nums1[i-1]==nums2[j-1]){
dp[i][j]=dp[i-1][j-1]+1;
}
if(dp[i][j]>result)result=dp[i][j];
}
}
return result;
}
};
1143.最长公共子序列
class Solution {
public:
int longestCommonSubsequence(string text1, string text2) {
vector<vector<int>>dp(text1.size()+1,vector<int>(text2.size()+1,0));
for(int i=1;i<=text1.size();i++){
for(int j=1;j<=text2.size();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[text1.size()][text2.size()];
}
};
1035.不相交的线
class Solution {
public:
int maxUncrossedLines(vector<int>& nums1, vector<int>& nums2) {
vector<vector<int>> dp(nums1.size()+1,vector<int>(nums2.size()+1,0));
for(int i=1;i<=nums1.size();i++){
for(int j=1;j<=nums2.size();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[nums1.size()][nums2.size()];
}
};
53.最大子序和
class Solution {
public:
int maxSubArray(vector<int>& nums) {
if(nums.size()==0)return 0;
vector<int> dp(nums.size());
dp[0]=nums[0];
int result=dp[0];
for(int i=1;i<nums.size();i++){
dp[i]=max(dp[i-1]+nums[i],nums[i]);
if(dp[i]>result)result=dp[i];
}
return result;
}
};
392.判断子序列
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];
}
}
if(dp[s.size()][t.size()]==s.size())return true;
return false;
}
};
115.不同的子序列
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()];
}
};
583.两个字符串的删除操作
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]+2,dp[i-1][j]+1,dp[i][j-1]+1});
}
}
}
return dp[word1.size()][word2.size()];
}
};
72.编辑距离
public:
int minDistance(string word1, string word2) {
vector<vector<int>> dp(word1.size()+1,vector<int>(word2.size()+1,0));
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-1][j],dp[i][j-1]})+1;
}
}
}
return dp[word1.size()][word2.size()];
}
};
647.回文子串
class Solution {
public:
int countSubstrings(string s) {
vector<vector<bool>> dp(s.size(),vector<bool>(s.size(),false));
int result=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){
result++;
dp[i][j]=true;
}else if(dp[i+1][j-1]){
result++;
dp[i][j]=true;
}
}
}
}
return result;
}
};
516.最长回文子序列
回文子串要求连续,回文子序列不要求连续
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];
}
};