完全背包、打家劫舍、买卖股票

原创 于 2022-03-29 13:22:39 发布 · 822 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#leetcode

本文详细解析了01背包问题和完全背包问题的解决方法，并通过具体实例如零钱兑换、单词拆分等展示了动态规划的应用技巧。同时，还探讨了不同场景下的动态规划策略，如打家劫舍系列问题及股票买卖最佳时机问题。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

01背包问题

物品只用一次

#include<bits/stdc++.h>
using namespace std;
int main(){
	int n,m;//物品数量n和背包容量m 
	while(cin>>n>>m){
		vector<int> w(m);
		vector<int> v(m);
		vector<int> dp(m+1,0);
		for(int i=0;i<n;++i){
			cin>>w[i]>>v[i];
		}
		for(int i=0;i<n;++i){
			for(int j=m;j>=w[i];--j){//！！倒序遍历
				dp[j]=max(dp[j],dp[j-w[i]]+v[i]);
			}
		}
		cout<<dp[m]<<endl;
		return 0;
	}
}

完全背包问题

物品可以用无限次

#include<bits/stdc++.h>
using namespace std;
int main(){
	int n,m;//物品数量n和背包容量m 
	while(cin>>n>>m){
		vector<int> w(m);
		vector<int> v(m);
		vector<int> dp(m+1,0);
		for(int i=0;i<n;++i){
			cin>>w[i]>>v[i];
		}
		for(int i=0;i<n;++i){
			for(int j=w[i];j<=m;++j){
				dp[j]=max(dp[j],dp[j-w[i]]+v[i]);
			}
		}
		cout<<dp[m]<<endl;
		return 0;
	}
}
322. 零钱兑换

动态规划dp[i]=min(dp[i-coin[j]]+1);

dp[i]是组成金额i的最少硬币个数，dp[i-coins[j]]是没加上coins[j]的最少硬币个数，dp[i-coins[j]]+1就是凑上coins[j]的最少硬币个数

属于完全背包

class Solution {
public:
    int coinChange(vector<int>& coins, int amount) {
		vector<int> dp(amount+1,amount+1);
		dp[0]=0;
		for(int i=0;i<coins.size();++i){//先遍历物品
			for(int j=coins[i];j<=amount;++j){//再遍历背包
					dp[j]=min(dp[j-coins[i]]+1,dp[j]);
			}
		}
		return dp[amount]>amount?-1:dp[amount];
    }
};
//先遍历背包再物品
//class Solution {
//public:
//    int coinChange(vector<int>& coins, int amount) {
//		vector<int> dp(amount+1,amount+1);
//		dp[0]=0;
//		for(int i=1;i<=amount;++i){
//			for(int j=0;j<coins.size();++j){
//				if(coins[j]<=i){
//					dp[i]=min(dp[i-coins[j]]+1,dp[i]);
//				}
//			}
//		}
//		return dp[amount]>amount?-1:dp[amount];
//    }
//};
518. 零钱兑换 II

递推公式：dp[j]+=dp[j-coins[i]];

完全背包求组合数：先遍历物品，再遍历背包

class Solution {
public:
    int change(int amount, vector<int>& coins) {
		int n=coins.size();
		vector<int> dp(amount+1);
		dp[0]=1;//无意义，为了dp的遍历
		for(int i=0;i<n;++i){
			for(int j=coins[i];j<=amount;++j){
				dp[j]+=dp[j-coins[i]];
			}
		} 
		return dp[amount];
    }
};
139. 单词拆分
class Solution {
public:
    bool wordBreak(string s, vector<string>& wordDict) {
		int n=s.size(); 
		vector<bool> dp(n+1,0);
		dp[0]=1;
		for(int i=0;i<n;++i){
			if(!dp[i]) continue;
			for(string word:wordDict){
				if(word.size()+i<=n&&s.substr(i,word.size())==word){
					dp[i+word.size()]=1;
				}
			}
		}
        return dp[n];
    }
};
//class Solution {
//public:
//    bool wordBreak(string s, vector<string>& wordDict) {
//		set<string> words(wordDict.begin(),wordDict.end());
//		vector<bool> dp(s.size()+1,0);
//		dp[0]=1;
//		for(int i=1;i<=s.size();++i){
//			for(int j=0;j<i;++j){
//				string cur=s.substr(j,i-j);
//				if(dp[j]&&words.find(cur)!=words.end()){
//					dp[i]=1;
//				}
//			}
//		}
//		return dp[s.size()];
//    }
//};
198. 打家劫舍
class Solution {
public:
    int rob(vector<int>& nums) {
		int n=nums.size();
        if(n==0) return 0;
        if(n==1) return nums[0];
		vector<int> dp(n);
		dp[0]=nums[0];
		dp[1]=max(nums[0],nums[1]);
		for(int i=2;i<n;++i){
			dp[i]=max(dp[i-1],dp[i-2]+nums[i]);
		}
		return dp[n-1];
    }
};
213. 打家劫舍 II
class Solution {
public:
    int rob(vector<int>& nums) {
		int n=nums.size();
		if(n==0) return 0;
        if(n==1) return nums[0];
        int res1=range(nums,n,0,n-2);
        int res2=range(nums,n,1,n-1);
        return max(res1,res2);
    }
    int range(vector<int>& nums,int n,int l,int r){
        if (l==r) return nums[l];
		vector<int> dp(n);
		dp[l]=nums[l];
		dp[l+1]=max(nums[l],nums[l+1]);
		for(int i=l+2;i<=r;++i){
			dp[i]=max(dp[i-1],dp[i-2]+nums[i]);
		}
		return dp[r];
	}
};
337. 打家劫舍 III
class Solution {
public:
	vector<int> dptree(TreeNode* cur){
        if(cur==NULL) return {0,0};
		vector<int> l=dptree(cur->left);
		vector<int> r=dptree(cur->right);
		int val1=max(l[0],l[1])+max(r[0],r[1]);
        int val2=cur->val+l[0]+r[0];
		return {val1,val2};
	}
    int rob(TreeNode* root) {
		vector<int> res=dptree(root);
		return max(res[0],res[1]);
    }
};
21. 买卖股票的最佳时机

贪心O(n)空间O(1)

class Solution {
public:
    int maxProfit(vector<int>& prices) {
		int n=prices.size();
		int low=INT_MAX;
		int res=0;
		for(int i=0;i<n;++i){
			low=min(low,prices[i]);
			res=max(res,prices[i]-low);//右边最大的-左边最小的
		}
		return res;
    }
};

动态规划

双O(n)

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<n;++i){
			//持有股票:前一天已经持有股票或在这一天买入股票 
			dp[i][0]=max(dp[i-1][0],-prices[i]);
			//不持有股票:前一天不持有股票或在当天卖掉股票 
			dp[i][1]=max(dp[i-1][1],dp[i-1][0]+prices[i]); 	
		}
		return dp[n-1][1];//不持有股票状态,即卖出状态总是最大		 	
    }
};

滚动数组：

O(n)O(1)

class Solution {
public:
    int maxProfit(vector<int>& prices) {
		int n=prices.size();
		vector<vector<int>> dp(2,vector<int>(2));//只记录两个状态向前递推
		dp[0][0]=-prices[0];
		dp[0][1]=0;
		for(int i=1;i<n;++i){
			//持有股票:前一天已经持有股票或在这一天买入股票 
			dp[i%2][0]=max(dp[(i-1)%2][0],-prices[i]); //%2后只有1和2两个状态
			//不持有股票:前一天不持有股票或在当天卖掉股票 
			dp[i%2][1]=max(dp[(i-1)%2][1],dp[(i-1)%2][0]+prices[i]); 	
		}
		return dp[(n-1)%2][1];		 	
    }
};
122. 买卖股票的最佳时机 II
class Solution {
public:
    int maxProfit(vector<int>& prices) {
		int res=0;
		for(int i=1;i<prices.size();i++){
			res+=max(prices[i]-prices[i-1],0);//把正的相邻右-左累加
		}
		return res;
    }
};

dp

还是0表示不持有，1表示持有好受点hh

class Solution {
public:
    int maxProfit(vector<int>& prices) {
		int n=prices.size();
		vector<vector<int>> dp(2,vector<int>(2));
		dp[0][0]=0;
		dp[0][1]=-prices[0];
		for(int i=1;i<n;++i){
			dp[i%2][0]=max(dp[(i-1)%2][0],dp[(i-1)%2][1]+prices[i]);
			dp[i%2][1]=max(dp[(i-1)%2][1],dp[(i-1)%2][0]-prices[i]);
		} 
		return dp[(n-1)%2][0];
    }
};
123. 买卖股票的最佳时机 III

懒得写，cv的

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        //dp[i][0]:无操作
        //dp[i][1]:第一次买入
        //dp[i][2]:第一次卖出
        //dp[i][3]:第二次买入
        //dp[i][4]:第二次卖出
        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) {
        int n=prices.size();
        if(n==0) return 0;
        vector<vector<int>> dp(n,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<n;++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[n-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][1]=-prices[0];
		for(int i=1;i<n;++i){
			//买入状态:即持有股票状态 
			dp[i][1]=max(dp[i-1][1],max(dp[i-1][2],dp[i-1][0]-prices[i]));
			//卖出状态，即不持有股票状态
			dp[i][0]=max(dp[i-1][1]+prices[i],max(dp[i-1][2],dp[i-1][0])); 
			//冷冻期
			dp[i][2]=dp[i-1][0]; 
		}
		return max(dp[n-1][2],dp[n-1][0]);
    }
};

答案：

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][1], dp[n - 1][2]));
    }
};
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值