贪心算法相关题
简单题目
455.分发饼干
class Solution {
public:
int findContentChildren(vector<int>& g, vector<int>& s) {
sort(g.begin(),g.end());
sort(s.begin(),s.end());
int count=0,i=0,j=0;
while(i<g.size()&&j<s.size()){
if(s[j]>=g[i]) {
count++;
i++;
}
j++;
}
return count;
}
};
1005.K次取反后最大化的数组和
class Solution {
public:
static bool cmp(int a,int b){
return abs(a)>abs(b);
}
int largestSumAfterKNegations(vector<int>& nums, int k) {
sort(nums.begin(),nums.end(),cmp);
int sum=0;
for(int i =0;i<nums.size();i++){
if(nums[i]<0&&k>0){
nums[i] = -nums[i];
k--;
}
}
if(k%2==1) nums[nums.size()-1]*=-1;
for(int i =0;i<nums.size();i++){
sum+=nums[i];
}
return sum;
}
};
860.柠檬水找零
class Solution {
public:
bool lemonadeChange(vector<int>& bills) {
map<int,int> map1;
for(int i =0;i<bills.size();i++){
if(bills[i]==5)
map1[5]++;
if(bills[i]==10){
map1[5]--;
map1[10]++;
if(map1[5]<0) return false;
}
if(bills[i]==20){
if(map1[10]){
map1[5]--;
map1[10]--;
}
else{
map1[5]-=3;
}
map1[20]++;
if(map1[5]<0||map1[10]<0) return false;
}
}
return true;
}
};
序列问题
376.摆动序列
法一：贪心法
局部最优：删除单调坡度上的节点（不包括单调坡度两端的节点），那么这个坡度就可以有两个局部峰值
整体最优：整个序列有最多的局部峰值，从而达到最长摆动序列。
我们根据正常理解，可以总结出我们需要统计波动的数量，定义prediff(nums[i]-nums[i-1])和curdiff(nums[i+1]-nums[i]),则波动需要满足的条件是：（prediff<0&&curdiff>0) || (prediff>0&&curdiff<0)。
但是这样会忽略平坡的情况，平坡分两种，
-
一是上下坡中有平坡，对于这种情况，我们只统计一个波动就好，默认统计prediff=0的情况，就是平坡在前，上下坡在后，统计这一波动，这对应的也是代码随想录中提到的删除平坡中左面的元素。
-
二是单调坡中有平坡，这对应的是我们应该修改对于prediff的更新，因为单调坡中的拐点使用上面的条件确实会被统计两次。
最后考虑两个数以及数组两端的情况，默认最右面有一个峰值（res=1起步），两个数的话无法判断写死摆动序列为2.
class Solution {
public:
int wiggleMaxLength(vector<int>& nums) {
if(nums.size()==2) {
if(nums[0]!=nums[1]) return nums.size();
if(nums[0]==nums[1]) return 1;
}
int prediff=0,curdiff=0,res=1;
for(int i =0;i<nums.size()-1;i++){
curdiff=nums[i+1]-nums[i];
if(prediff<=0&&curdiff>0||prediff>=0&&curdiff<0){
res++;
prediff=curdiff;
}
}
return res;
}
};
法二：动态规划
dp数组含义：
- dp[i][0]:表示考虑前i个数，第i个数作为山峰的摆动子序列最长长度
- dp[i][1]:表示考虑前i个数，第i个数作为山谷的摆动子序列最长长度
递推表达式：
dp[i][0] = max(dp[i][0],dp[j][1]+1) 其中0<j<i，其nums[j]<nums[i]，表示将nums[i]接到某个山谷后面作为山峰的最长长度。
dp[i][1] = max(dp[i][1],dp[j][0]+1) 其中0<j<i，其nums[j]>nums[i]，表示将nums[i]接到某个山峰后面作为山谷的最长长度
class Solution {
public:
int dp[1010][2];
int wiggleMaxLength(vector<int>& nums) {
memset(dp,0,sizeof(dp));
dp[0][0]=dp[0][1] = 1;
for(int i =1;i<nums.size();i++)
{
dp[i][0] = dp[i][1] = 1;
for(int j =0;j<i;j++)
if(nums[i]>nums[j]) dp[i][0] = max(dp[i][0],dp[j][1]+1);
for(int j=0;j<i;j++)
if(nums[i]<nums[j]) dp[i][1] = max(dp[i][1],dp[j][0]+1);
}
return max(dp[nums.size()-1][0],dp[nums.size()-1][1]);
}
};
单调递增的数字
class Solution {
public:
int monotoneIncreasingDigits(int n) {
if (n < 10) return n;
string str = "";
while (n) {
char c = n % 10 + '0';
str += c;
n = n / 10;
}
reverse(str.begin(), str.end());
for(int i =1;i<str.size();i++){
if(str[i]<str[i-1]){
str[i-1]-=1;
for(int j=i;j<str.size();j++){
str[j]='9';
}
for(int k=i-2;k>=0;k--){
if(str[k]>str[k+1]){
str[k]-=1;
str[k+1]='9';
}
}
}
}
int num = 0;
for (int i = 0; i < str.size(); i++) {
num = num*10+str[i] - '0';
}
return num;
}
};
简化版本
从后往前遍历，如果出现strNum[i - 1] > strNum[i]的情况，则strNum[i - 1]–，然后一直用一个flag记录i的位置，以便于之后将i之后所有卫生纸上的数字
class Solution {
public:
int monotoneIncreasingDigits(int N) {
string strNum = to_string(N);
// flag用来标记赋值9从哪里开始
// 设置为这个默认值，为了防止第二个for循环在flag没有被赋值的情况下执行
int flag = strNum.size();
for (int i = strNum.size() - 1; i > 0; i--) {
if (strNum[i - 1] > strNum[i] ) {
flag = i;
strNum[i - 1]--;
}
}
for (int i = flag; i < strNum.size(); i++) {
strNum[i] = '9';
}
return stoi(strNum);
}
};
有点难度
53.最大子序和
贪心算法
class Solution {
public:
int maxSubArray(vector<int>& nums) {
int count=0,res=INT32_MIN;
for(int i =0;i<nums.size();i++)
{
count+=nums[i];
res = count>res?count:res;
if(count<=0) count=0;
}
return res;
}
};
动态规划
这道题写动规的时候，dp的含义直接设置成了前i个连续子数组的最大和，没有再设置res去保存最大值，导致dp[i]在更新的时候到底是最大值还是只是和的时候，出现了两层表示意义。比如1，2，3，-7，6，dp[3] = 6，但dp[3]按照原有含义，没有办法直接+nums[4]。
class Solution {
public:
int dp[100010];
int maxSubArray(vector<int>& nums) {
memset(dp,0,sizeof(dp));
int res = nums[0];
dp[0] = nums[0];
for(int i =1;i<nums.size();i++){
dp[i] = max(dp[i-1]+nums[i],nums[i]);
if(dp[i]>res) res=dp[i];
}
return res;
}
};
134.加油站
class Solution {
public:
int canCompleteCircuit(vector<int>& gas, vector<int>& cost) {
int min_gas = 0,sum_gas=0;
for(int i =0;i<gas.size();i++){
sum_gas=sum_gas+gas[i]-cost[i];
if(sum_gas<min_gas) min_gas=sum_gas;
}
if(sum_gas<0) return -1;
else{
sum_gas=0;
for(int i=gas.size()-1;i>=0;i--){
sum_gas+=gas[i]-cost[i];
if(sum_gas>=-min_gas){
return i;
}
}
}
return -1;
}
};
968.监控二叉树
/**
* 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:
// 0:表示该节点没有被覆盖
// 1:表示该节点有摄像头
// 2:表示该节点被覆盖
int ans;
int traversal(TreeNode* cur){
if(cur==nullptr) return 2;
int left = traversal(cur->left);
int right = traversal(cur->right);
if(left==0||right==0) {
ans++;
return 1;
}
if(left==1||right==1){
return 2;
}
if(left==2||right==2){
return 0;
}
return -1;
}
int minCameraCover(TreeNode* root) {
int root_num = traversal(root);
if(root_num==0) ans++;
return ans;
}
};
两个维度权衡问题
分发糖果
class Solution {
public:
int candy(vector<int>& ratings) {
vector<int> candy(ratings.size(),1);
for(int i=1;i<ratings.size();i++){
if(ratings[i]>ratings[i-1]){
candy[i] = candy[i-1]+1;
}
}
for(int i=ratings.size()-1;i>0;i--){
if(ratings[i-1]>ratings[i]){
candy[i-1]=max(candy[i]+1,candy[i-1]);
}
}
int ans=0;
for(int i =0;i<candy.size();i++){
ans+=candy[i];
}
return ans;
}
};
406.根据身高重建队列
现根据身高从大到小排列，再根据k一个一个插入。
class Solution {
public:
static bool cmp(vector<int>& a,vector<int>& b){
if(a[0]==b[0]) return a[1]<b[1];
else return a[0]>b[0];
}
vector<vector<int>> reconstructQueue(vector<vector<int>>& people) {
sort(people.begin(),people.end(),cmp);
vector<vector<int>> que;
for(int i =0;i<people.size();i++){
int position = people[i][1];
que.insert(que.begin()+position,people[i]);
}
return que;
}
};
贪心解决股票问题
122.买卖股票的最佳时机II
贪心法
class Solution {
public:
int maxProfit(vector<int>& prices) {
int sum=0;
for(int i =1;i<prices.size();i++){
if(prices[i]-prices[i-1]>0){
sum+=prices[i]-prices[i-1];
}
}
return sum;
}
};
动规法
class Solution {
public:
int dp[30010];
int maxProfit(vector<int>& prices) {
memset(dp,0,sizeof(dp));
int sum=0;
for(int i =1;i<prices.size();i++){
dp[i]=dp[i-1] + max(prices[i]-prices[i-1],0);
}
return dp[prices.size()-1];
}
};
区间问题
区间问题总结，除了两个跳跃游戏。我们一共左了四个区间的贪心算法题。用最少弓箭射爆气球，五重叠区间的个数，划分字母区间和合并区间。用最少的弓箭射爆气球，实际上我们要找的是重叠区间的个数，而射爆气球这道题认为[1,2],[2,3]不属于重叠区间，这需要注意。我们按照左边界排序后，只需要遍历interval中每一个右边界，每次更新重叠区间的右端点 r = min ( points [ i ] [ 1 ] , r ) r = \text {min}(\text{points}[i][1],r) r=min(points[i][1],r)，然后处理每个interval左边界和r的关系就好。无重叠区间的个数实际上总区间个数减去重叠区间个数，所以看清楚条件[1,2],[2,3]属不属于重叠情况确立等号是否成立。划分字母区间这道题有点难度，需要统计每个字符出现的最远位置下标然后处理。合并区间，按左边界排序后，然后从左到右遍历看是否是重叠的，然后更新合并区间的左边界右边界。
55.跳跃游戏
贪心法
class Solution {
public:
bool canJump(vector<int>& nums) {
int step=0;
if(nums.size()==1) return true;
for(int i =0;i<=step;i++){
step=max(i+nums[i],step);
if(step>=nums.size()-1) return true;
}
return false;
}
};
45.跳跃游戏II
动态规划
class Solution {
public:
//我的思路是：dp数组表示到第i个格子需要的最短次数
//dp数组更新的递推公式是：从j=0个格子开始找
int dp[10100];
int jump(vector<int>& nums) {
memset(dp, 10010, sizeof(dp));
if (nums.size() == 1) return 0;
else dp[0] = 0;
for (int i = 1; i < nums.size(); i++) {
for (int j = 0; j < i; j++) {
if (j + nums[j] >= i) {
dp[i] = min(dp[j] + 1, dp[i]);
break;
}
}
}
return dp[nums.size() - 1];
}
};
452.用最少数量的箭引爆气球
class Solution {
public:
static bool cmp(vector<int>& a, vector<int>& b){
if(a[0]==b[0]) return a[1]<b[1];
else return a[0]<b[0];
}
int findMinArrowShots(vector<vector<int>>& points) {
sort(points.begin(),points.end(),cmp);
int l=points[0][0],r=points[0][1];
int ans=1;
for(int i =1;i<points.size();i++){
l = points[i][0];
r = min(points[i][1],r);
if(l>r){
r=points[i][1];
ans++;
}
}
return ans;
}
};
435.无重叠区间
class Solution {
public:
//无重叠区间的个数等于总区间个数减去重叠区间个数
static bool cmp(vector<int>& a,vector<int>& b){
if(a[1]==b[1]) return a[0]<b[0];
else return a[1]<b[1];
}
int eraseOverlapIntervals(vector<vector<int>>& intervals) {
//这里需要记一下，按右边界排序要从左向右找
//按左边界排序，要从右向左找
sort(intervals.begin(),intervals.end(),cmp);
int l=intervals[0][0],r=intervals[0][1];
int ans=1;
for(int i =1;i<intervals.size();i++){
if(intervals[i][0]>=r){
ans++;
r=intervals[i][1];
}
}
return intervals.size()-ans;
}
};
736.划分字母区间
这道题不用回溯，不是所有的划分字母区间都要回溯，这道题主要在于统计之前遍历过所有字母的最远边界，如果当前下标到达了这个最远边界，说明到达了字符串的分割点。
class Solution {
public:
//贪心法
map<char,int> mp;
vector<int> ans;
vector<int> partitionLabels(string s) {
for(int i =0;i<s.size();i++){
mp[s[i]] = i;
}
int split=0,split1=-1;
for(int i =0;i<s.size();i++){
if(mp[s[i]]>split) split=mp[s[i]];
if(i==split){
ans.push_back(split-split1);
split1= split;
}
}
return ans;
}
};
56.合并区间
通过做这道题，我先是按照解上面题的常规套路，按照右边界排序，后来发现很多bug，这道合并区间的题如果从左到右遍历一定是先按左边界排列。
class Solution {
public:
static bool cmp(vector<int>&a, vector<int>&b){
if(a[0]==b[0]) return a[1]<b[1];
else return a[0]<b[0];
}
vector<vector<int>> res;
vector<vector<int>> merge(vector<vector<int>>& intervals) {
sort(intervals.begin(),intervals.end(),cmp);
int l = intervals[0][0];
int r = intervals[0][1];
for(int i =1;i<intervals.size();i++){
if(intervals[i][0]<=r){
r = max(intervals[i][1],r);
}
else{
res.push_back({l,r});
l = intervals[i][0];
r = intervals[i][1];
}
}
res.push_back({l,r});
return res;
}
};
补充（改版自弓箭数量那题）
class Solution {
public:
//无重叠区间的个数等于总区间个数减去重叠区间个数
static bool cmp(vector<int>& a, vector<int>& b){
if(a[0]==b[0]) return a[1]<b[1];
else return a[0]<b[0];
}
int eraseOverlapIntervals(vector<vector<int>>& intervals) {
sort(intervals.begin(),intervals.end(),cmp);
int l=intervals[0][0],r=intervals[0][1];
int ans=1;
for(int i =1;i<intervals.size();i++){
l = intervals[i][0];
r = min(intervals[i][1],r);
if(l>=r){ //加个等号，认为等于的情况不属于交叉区间
r=intervals[i][1];
ans++;
}
}
return intervals.size()-ans;
}
};
贪心
要从覆盖范围出发，不管怎么跳，覆盖范围一定是可以跳到的，以最小的步数增加覆盖范围，覆盖范围一旦覆盖了重点得到的就是最小步数。
class Solution {
public:
int jump(vector<int>& nums) {
if(nums.size()==1) return 0;
int curmaxindex = 0; // 当前覆盖最远距离下标，当前位置为i的话，能走到的最远距离就是i+nums[i]。
int nextmaxindex = 0; // 记录走的最大步数
int step = 0; // 下一步覆盖最远距离下标
for(int i =0;i<=curmaxindex;i++){
nextmaxindex = max(nums[i]+i,nextmaxindex); // 更新下一步能走到的最远距离
if(i==curmaxindex){ // 如果i已经走到了当前能走到的最大距离
if(curmaxindex<nums.size()-1){
step++; // 那么我们一定要走下一步了，但下一步的落脚点在哪儿不用管
// 不要误认为下一步落脚点一定是curdistance，这个没关系
curmaxindex=nextmaxindex; // 更新当前覆盖最远距离下标
if(nextmaxindex>=nums.size()-1) break; // 下一步的覆盖范围已经可以达到终点，结束循环
}
}
}
return step;
}
};
538
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
