leetcode-贪心思想

最新推荐文章于 2024-07-09 23:27:44 发布
最新推荐文章于 2024-07-09 23:27:44 发布
阅读量574 收藏
点赞数
文章标签： leetcode 贪心算法 算法 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Kuches/article/details/122064923
版权

leetcode-贪心算法

前言

记录leetcode中几道贪心算法的C++解法，以及思路。

一、455-分配饼干

思路：尽量做到小的饼干分给小胃口的孩子，才能做到满足更多孩子的胃口。所以首先需要对两个数组进行排序，然后遍历比较满足孩子胃口的饼干个数。
C++代码如下：

#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>

class Solution {
public:
	int findContentChildren(vector<int>& g, vector<int>& s) {
		sort(g.begin(), g.end());//sort算法默认以非递减顺序排序
		sort(s.begin(), s.end());
		int i = 0, j = 0;//g[i]记录当前孩子的胃口，s[j]记录当前饼干
		int ret = 0;//ret用于记录可以最多满足孩子胃口的个数
		while (i < g.size() && j < s.size()) {
			if (s[j] >= g[i]) {//如果当前饼干的大小满足当前孩子的胃口
				ret++;
				i++;//换下一个孩子(下一个孩子的胃口大于等于当前孩子的胃口）
				j++;//换下一块饼干（下一块饼干一定大于等于当前饼干，这也是需要排序的原因）
			}
			else {
				//如果当前饼干不满足当前孩子的胃口，换下一块饼干
				j++;
			}
		}
		return ret;
	}
};
int main()
{
	vector<int>g = { 3,1 };
	vector<int>s = { 1,2,3 };
	cout << Solution().findContentChildren(g, s) << endl;
	system("pause");

	return 0;
}

二、435-不重叠的区间个数

思路：理解队右侧区间进行排序的原因，用下一个区间的左侧区间和当前右侧区间进行比较，如果下一个区间的左侧区间大于等于当前的右侧区间，说明两个区间不重叠。

C++代码如下：

#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>
class Solution {
public:
	class myCompare {
	public:
		bool operator()(const vector<int>&l, const vector<int>&r) {
			return l[1] < r[1];
		}
	};
	int eraseOverlapIntervals(vector<vector<int>>& intervals) {
		if (intervals.size() == 0)return 0;//如果数组为空，直接返回0

		//需要对数组进行排序，排序的规则是，右侧边界由小到大排列（排序时不需要关注左侧边界）
		sort(intervals.begin(), intervals.end(), myCompare());

		int n = 1;//n表示最大的不重叠区间的个数
		int right = intervals[0][1];//记录当前的右侧区间
		for (int i = 1; i < intervals.size(); ++i) {
		//如果当前区间的左侧区间大于等于当前的右侧区间，说明这两个区间不重叠，n+1
			if (intervals[i][0] >= right) {
				n++;
				right = intervals[i][1];
			}
		}
		return intervals.size() - n;//删除的个数，等于总的区间数减去不重叠区间数
	}
};

三、452-用最少量的箭引爆气球

思路：这个题的本质就是求不重叠区间的个数（注意边界条件）
C++代码如下：

#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>

class Solution {
public:
	class myCompare {
	public:
		bool operator()(const vector<int>&l, const vector<int>&r) {
			return l[1] < r[1];
		}
	};
	int findMinArrowShots(vector<vector<int>>& points) {
		//右侧区间由小到大进行排序
		sort(points.begin(), points.end(), myCompare());

		int n=1;
		int right = points[0][1];
		for (int i = 1; i < points.size(); ++i) {
			if (points[i][0] > right) {
				n++;
				right = points[i][1];
			}
		}
		return n;
	}
};
int main()
{

	vector<vector<int>>points = { {1,2},{1,2} };
	cout << Solution().findMinArrowShots(points) << endl;
	system("pause");

	return 0;
}

四、406-根据身高重建队列

思路：这种涉及两种特征的一般都需要排序，但是要想清楚对身高进行排序的规则以及对序号的排序规则。
C++代码如下：

#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>
class Solution {
public:
	class myCompare {
	public:
		bool operator()(const vector<int>&l, const vector<int>&r) {
			if (l[0] == r[0])return l[1] < r[1];
			return l[0] > r[0];
		}
	};
	vector<vector<int>> reconstructQueue(vector<vector<int>>& people) {
		//身高高的排在前面，身高相同的序号小的排在前面
		sort(people.begin(), people.end(), myCompare());
		vector<vector<int>>ret;
		for (int i = 0; i < people.size(); ++i) {
			ret.insert(ret.begin() + people[i][1], people[i]);
		}
		return ret;
	}
};
int main()
{
	vector<vector<int>>people = { {7,0},{4,4},{7,1},{5,0},{6,1},{5,2} };
	vector<vector<int>>ans = Solution().reconstructQueue(people);
	for (auto m : ans) {
		cout << "[" << m[0] << "," << m[1] << "]" << endl;
	}
	system("pause");

	return 0;
}

五、121-买卖股票的最佳时机

思路：卖出股票的日期必须在买入股票日期的后面，利用数据在数组的先后顺序模拟日期的先后顺序，记录最低价格和最大利润。
C++代码如下：

#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>
class Solution {
public:
	int maxProfit(vector<int>& prices) {
		int minprice = (int)1e5;//最低价格
		int maxprofit = 0;		//最大利润
		for (auto m:prices) {
			//利用原本在数组中的先后顺序，模拟日期的先后顺序
			maxprofit = max(maxprofit, m - minprice);
			minprice = min(minprice, m);
		}
		return maxprofit;
	}
};
int main()
{

	vector<int>prices = { 7,6,5,4 };
	cout << Solution().maxProfit(prices) << endl;
	system("pause");

	return 0;
}

六、122-买卖股票的最佳时机Ⅱ

思路：当前元素大于前一个元素说明对最大利益有增益作用就保留，如果当前元素不大于前一个元素就不叠加。
C++代码如下：

#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>
class Solution {
public:
	int maxProfit(vector<int>& prices) {
		if (prices.size() == 1)return 0;

		int maxprofit = 0;
		for (int i = 1; i < prices.size(); ++i) {
			maxprofit += max(0, prices[i] - prices[i-1]);
		}
		return maxprofit;
	}
};

int main()
{
	vector<int>prices = { 1,2,3,4,5};
	cout << Solution().maxProfit(prices) << endl;
	system("pause");

	return 0;
}

七、605-种花问题

思路：记连续的0的个数为count,(count-1)/2表示能够再种花的数量。遇到1的时候就将重置count为0。特别地要考虑第一个元素、最后一个元素为0和只有一个元素的情况。
C++代码如下：

#include<iostream>
using namespace std;
#include<vector>
class Solution {
public:
	bool canPlaceFlowers(vector<int>& flowerbed, int n) {
		if (flowerbed.size() == 1) {
			if (flowerbed[0] == 0 && n <= 1) {
				return true;
			}
		}
		int count = 0;
		for (int i = 0; i < flowerbed.size(); ++i) {
			if (flowerbed[i] == 0) {
				//如果是第一个花盆或者最好一个花盆，额外加添加一个0
				if (i == 0||i==flowerbed.size()-1) count++;
				count++;
			}
			else {
				n -= (count - 1) / 2;
				if (n <= 0) {
					return true;
				}
				count = 0;
			}
			if (i == flowerbed.size() - 1&& flowerbed[i] == 0) {
				//上面程序没有考虑最后一个元素为0结束的情况
				n -= (count - 1) / 2;
			}
		}
		return n <= 0;
	}
};

int main()
{
	vector<int>flowerbed = { 1,0,1,0,0 };
	cout << Solution().canPlaceFlowers(flowerbed, 1) << endl;
	system("pause");

	return 0;
}

八、392-判断子序列

思路：双指针遍历
C++代码如下：

#include<iostream>
using namespace std;
#include<string>
class Solution {
public:
	bool isSubsequence(string s, string t) {
		int i = 0, j = 0;
		while (i < s.length() && j < t.length()) {
			if (s[i] == t[j]) {
				i++;
				j++;
			}
			else {
				j++;
			}
		}
		return i == s.length();
	}
};

int main()
{

	cout << Solution().isSubsequence("abc", "ab") << endl;
	system("pause");

	return 0;
}

九、665-非递减数列

思路：主要是将情况考虑全面，例如当出现前一个元素大于后一个元素时，应该删除前面一个元素还是后面一个元素。在删除时，要考虑是否被删除元素前面的元素全部都大于后面的元素，以及被删除的元素为第一个元素或者最后一个元素的情况。
C++代码如下：

#include<iostream>
using namespace std;
#include<vector>
class Solution {
public:
	bool subCheck(vector<int>&nums, int k) {
		if (k != 0 && k != nums.size() - 1 && nums[k + 1] < nums[k - 1])return false;
		for (int i = k+2; i < nums.size(); i++) {
			if (nums[i] < nums[i - 1])return false;
		}
		return true;
	}
	bool checkPossibility(vector<int>& nums) {
		for (int i = 1; i < nums.size(); ++i) {
			if (nums[i] < nums[i - 1]) {
				if (!subCheck(nums, i) && !subCheck(nums, i - 1)) {
					return false;
				}
			}
		}
		return true;
	}
};

int main()
{

	vector<int>nums = { 3,4,2,3 };
	cout << Solution().checkPossibility(nums) << endl;
	system("pause");

	return 0;
}

十、53-最大子数组和

思路：要发现叠加的规律，如果前面的子数组之和为正，就对当前元素有增益作用。但是不能保证当前元素为正，所以需要用一个变量记录最大值。
C++代码如下：

#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>
class Solution {
public:
	int maxSubArray(vector<int>& nums) {
		int ans = 0;//记录子数组之和
		int maxValue=-1e5;//记录最大值
		for (int i = 0; i < nums.size(); ++i) {
			//前一个子数组对当前元素是否有增益，如果有就保留
			ans = max(nums[i], ans + nums[i]);

			//虽然前一个子数组对当前元素可能有增益，但是不能保证目前元素为正
			maxValue = max(ans, maxValue);
		}
		return maxValue;
	}
};
int main()
{

	vector<int>nums = {5, 4, -1, 7,8};
	cout << Solution().maxSubArray(nums) << endl;
	system("pause");

	return 0;
}

十一、763-划分字母区间

思路：主要是通过一个数组记录各个字符的结束地址
C++代码如下：

#include<iostream>
using namespace std;
#include<vector>
#include<string>
#include<algorithm>
class Solution {
public:
	vector<int> partitionLabels(string s) {
		int last[26];//用last数组记录字符串元素的最后出现的位置
		for (int i = 0; i < s.length(); ++i) {
			last[s[i] - 'a'] = i;
		}

		int right = 0;//元素结束地址
		int l = 0;//元素起始地址
		vector<int>ret;
		for (int i = 0; i < s.length(); ++i) {
			right = max(right, last[s[i] - 'a']);//更新结束地址
			if (i == right) {
				ret.push_back(i - l + 1);//将起始到结束的元素记录到数组中
				l = i + 1;//更新起始地址
			}
		}
		return ret;
	}
};
int main()
{

	vector<int>nums = Solution().partitionLabels("asdfsfsabnininibcopopc");
	for (auto m : nums)cout << m << " ";
	cout << endl;
	system("pause");

	return 0;
}

参考

leetcode题解
leetcode官网

Kuches
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
leetcode答案-leetcode-php:leetcode-php
06-30
1. **算法解析**：每道题的解答都体现了特定的算法思想，如排序、递归、动态规划、贪心算法等，理解这些算法是提升编程能力的关键。 2. **数据结构应用**：观察代码如何利用PHP中的数组、哈希表、链表等数据结构来...
leetcode跳跃-LeetCode-Java:LeetCode-Java
06-30
在给定的标题"leetcode跳跃-LeetCode-Java:LeetCode-Java"中，我们可以推测这是一个关于使用Java语言解决LeetCode算法问题的项目。LeetCode是一个在线平台，它提供了各种编程挑战，旨在帮助开发者提高他们的算法技能...
LeetCode算法思想
leeeeeena's blog
03-27 573
36. Valid Sudoku 数独，题目要求，每一行，每一列，每个小的九宫格不能出现同样的数字（数字为0~9）， 算法思想： （1）判断每一行有没有相同的数字 （2）判断每一列有没有相同的数字 （3）每个小的九宫格有没有相同的数字。          //稍微需要考虑的是对于9X9的九宫格应该怎么遍历每一个3X3的九宫格 64. Minimum Path Sum
leetcode涉及的思想
xgl112112的专栏
03-27 356
1.DFS 2.到目前为止。。。。
LeetCode Dynamic Programming 算法思想-动态规划
junruixue
06-20 252
5. Longest Palindromic Substring最长回文子串题目描述：给定一个字符串 s，找到 s 中最长的回文子串。你可以假设 s 的最大长度为1000。示例 1：输入: "babad" 输出: "bab" 注意: "aba"也是一个有效答案。 示例 2：输入: "cbbd" 输出: "bb"思路分析：动态规划求解：回文字符串的子串也回文，比如P[i,j]（表示以i开始以j结束的...
Leetcode常用五大算法思想
坐而言不如起而行
06-14 2687
算法 目录(?)[-] 分治算法动态规划贪心算法回溯法分支限界法 分治算法 一、基本概念    在计算机科学中，分治法是一种很重要的算法。字面上的解释是“分而治之”，就是把一个复杂的问题分成两个或更多的相同或相似的子问题，再把子问题分成更小的子问题……直到最后子问题可以简单的直接求解，原问题的解即子问题的解的合并。这个技巧是很多高效算法的基础，如排序算
LeetCode 455. 分发饼干
午夜的行人
12-07 1152
题目 假设你是一位很棒的家长，想要给你的孩子们一些小饼干。但是，每个孩子最多只能给一块饼干。 对每个孩子 i，都有一个胃口值 g[i]，这是能让孩子们满足胃口的饼干的最小尺寸；并且每块饼干 j，都有一个尺寸 s[j] 。如果 s[j] >= g[i]，我们可以将这个饼干 j 分配给孩子 i ，这个孩子会得到满足。你的目标是尽可能满足越多数量的孩子，并输出这个最大数值。 示例 1: 输入: g = [1,2,3], s = [1,1] 输出: 1 解释: 你有三个孩子和两块小饼干，3个孩子的胃口值分别是
leetcode刷题--贪心算法
weixin_44911248的博客
02-14 3396
七. 贪心算法 文章目录七. 贪心算法1. 605 种花问题2. 121 买卖股票的最佳时机3. 561 数组拆分4. 455 分发饼干5. 575 分糖果6. 135 分发糖果7. 409 最长回文串8. 621 任务调度器9. 179 最大数10. 56 合并区间11. 57 插入区间13. 452 用最少数量的箭引爆气球14. 435 无重叠区间15. 646 最长数对链16. 406 按照身高重建队列17. 48 旋转图像18. 169 多数元素19. 215 数组中的第k个最大元素20. 75
LeetCode-贪心算法
a445673440的博客
11-26 504
记录，整理LeetCode中与“贪心算法”相关的题目
Leetcode-贪心算法
weixin_42127177的博客
12-17 2402
55-跳跃游戏 给定一个非负整数数组 nums ，你最初位于数组的 第一个下标 。 数组中的每个元素代表你在该位置可以跳跃的最大长度。 判断你是否能够到达最后一个下标。 class Solution { public: bool canJump(vector<int>& nums) { int n=nums.size(); int farthest=0; if(n==1) return true;
力扣LeetCode-贪心算法
weixin_56005963的博客
03-04 2347
贪心算法 基本知识 1.思想 基于局部最优的选择逐渐推导出全局最优解 2.一般步骤 将问题分解为若干个子问题； 找出合适的贪心策略； 求解每一个子问题的最优解； 将局部最优解合成为全局最优解； 典型例题 1. LeetCode 376. 摆动序列 题目 如果连续数字之间的差严格地在正数和负数之间交替，则数字序列称为 摆动序列 。第一个差（如果存在的话）可能是正数或负数。仅有一个元素或者含两个不等元素的序列也视作摆动序列。 例如， [1, 7, 4, 9
leetcode答案-leetcode-java:leetcode-java
06-30
4. 贪心算法：局部最优选择来达到全局最优，如活动选择问题、区间调度问题。 5. 图论：深度优先搜索（DFS）和广度优先搜索（BFS）是图问题的基本解法，如最短路径问题、最小生成树等。 三、实战经验与技巧分享 在...
leetcode-java
05-13
3. 动态规划：通过实例理解动态规划的基本思想和状态转移方程的建立。 4. 贪心算法：针对局部最优解进行求解，适用于部分问题。 5. 回溯法：在解决问题时，通过回溯寻找所有可能的解。 四、LeetCode实战 1. 字符串...
leetcode答案-leetcode-rust:leetcode练习
06-30
8. **LeetCode算法**：分析每个问题的解决方案，理解算法思想，如分治、动态规划、回溯、贪心和二分查找等。 通过阅读和理解这些代码，你不仅能提升Rust编程技能，还能加深对算法的理解。同时，项目的开源性质意味...
leetcode--恢复二叉搜索树
最新发布
liulanba的博客
07-09 282
给你二叉搜索树的根节点 root ，该树中的 恰好 两个节点的值被错误地交换。请在不改变其结构的情况下，恢复这棵树。示例 1：输入：root = [1,3,null,null,2]输出：[3,1,null,null,2]解释：3 不能是 1 的左孩子，因为 3 > 1。交换 1 和 3 使二叉搜索树有效。示例 2：输入：root = [3,1,4,null,null,2]输出：[2,1,4,null,null,3]解释：2 不能在 3 的右子树中，因为 2 < 3。
刷leetcode中常用且有效的方法总结
路有瑶台的博客
07-04 286
刷题的时候经常会因为不知道一个方法多写很多行代码，既然有trick为何不用！你问我眼中为何常含泪水，因为我忘记方法忘的深沉。join（）是 Python 中的一个字符串方法，它用于将序列（如列表、元组、集合等，但集合需要首先转换为列表或其他有序序列，因为集合是无序的）中的元素以指定的字符连接生成一个新的字符串。方法来更新计数器中的计数。可以传递另一个可迭代对象或者另一个。提供了一个快速简单的方式来统计哈希对象在集合中出现的次数。
力扣考研经典题 反转链表
qq_55751640的博客
07-07 296
头插法： 不断的将cur指针所指向的节点放到头节点之前，然后头节点指向cur节点，因为最后返回的是head.next。
【力扣】数组中的第K个最大元素
m0_61876562的博客
07-05 279
l, left]（该部分小于基准元素key）、[left + 1, right - 1]（等于基准元素key）、[right, r]（大于基准元素key）。3、计算每部分所包含的元素个数，分别为a 、b = right - left - 1、 c = r - right + 1;请注意，你需要找的是数组排序后的第。你必须设计并实现时间复杂度为。个最大的元素，而不是第。1、随机选择基准元素。
leetcode中贪心算法
07-27
贪心算法是一种常用的算法思想，常用于求解优化问题。在LeetCode上，有许多使用贪心算法解决的问题。 其中一道经典的贪心算法题目是"Jump Game"（跳跃游戏）。题目要求判断能否从数组的第一个元素跳到最后一个元素...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值