贪心算法
文章目录
455. 分发饼干
假设你是一位很棒的家长,想要给你的孩子们一些小饼干。但是,每个孩子最多只能给一块饼干。
对每个孩子 i
,都有一个胃口值 g[i]
,这是能让孩子们满足胃口的饼干的最小尺寸;并且每块饼干 j
,都有一个尺寸 s[j]
。如果 s[j] >= g[i]
,我们可以将这个饼干 j
分配给孩子 i
,这个孩子会得到满足。你的目标是尽可能满足越多数量的孩子,并输出这个最大数值。
class Solution {
public:
int findContentChildren(vector<int>& g, vector<int>& s) {
sort(g.begin(),g.end());
sort(s.begin(),s.end());
int sum = 0;
for(int i = 0,j = 0;i < g.size() && j < s.size();j++){
if(s[j] >= g[i]){
sum++,i++;
}
}
return sum;
}
};
367. 有效的完全平方数
给你一个正整数 num
。如果 num
是一个完全平方数,则返回 true
,否则返回 false
。
完全平方数 是一个可以写成某个整数的平方的整数。换句话说,它可以写成某个整数和自身的乘积。
不能使用任何内置的库函数,如 sqrt
。
class Solution {
public:
bool isPerfectSquare(int num) {
int left = 0,right = num;
while(left <= right){
long long mid = (left + right) / 2;
if(mid * mid == num){
return true;
}else if(mid * mid > num){
right = mid -1;
}else{
left = mid +1;
}
}
return false;
}
};
53. 最大子数组和
给你一个整数数组 nums
,请你找出一个具有最大和的连续子数组(子数组最少包含一个元素),返回其最大和。
子数组 是数组中的一个连续部分。
1
class Solution {
public:
int max(int one,int two){
if(one > two){
return one;
}
else{
return two;
}
}
int maxSubArray(vector<int>& nums) {
bool flag = 0;//首先把前面负数排除,其次中间如果累加变成负数也是flag=0
int sum = nums[0] ,max = sum;
for(int i = 1;i < nums.size();i++){
if(sum <= 0 && flag == 0 && nums[i] <= 0){
sum = this->max(nums[i],sum);
continue;
}
flag = 1;
if(sum <= 0)sum = 0;
sum += nums[i];
max = this->max(sum,max);
if(sum <= 0){
flag = 0;
}
}
max = this->max(max,sum);
return max;
}
};
2
class Solution {
public:
int maxSubArray(vector<int>& nums) {
vector<int>dp(nums.size() + 1,0);
int mymax = INT_MIN;
for(int i = 0;i < nums.size();i++){
dp[i + 1] = max(nums[i] + dp[i],nums[i]);
mymax = max(mymax,dp[i + 1]);
}
return mymax;
}
};
55. 跳跃游戏
给定一个非负整数数组 nums
,你最初位于数组的 第一个下标 。
数组中的每个元素代表你在该位置可以跳跃的最大长度。
判断你是否能够到达最后一个下标。
class Solution {
public:
//直接i+num值
bool canJump(vector<int>& nums) {
if(find(nums.begin(),nums.end(),0) == nums.end())return true;
if(nums.size() <= 1)return true;
int k = 0;
for(int i = 0;i < nums.size();i++){
if(i > k)return false;
k = max(k,i + nums[i]);
}
return true;
}
};
45. 跳跃游戏 II
给定一个长度为 n
的 0 索引整数数组 nums
。初始位置为 nums[0]
。
每个元素 nums[i]
表示从索引 i
向前跳转的最大长度。换句话说,如果你在 nums[i]
处,你可以跳转到任意 nums[i + j]
处:
0 <= j <= nums[i]
i + j < n
返回到达 nums[n - 1]
的最小跳跃次数。生成的测试用例可以到达 nums[n - 1]
。
class Solution {
public:
int jump(vector<int>& nums) {
int sum = 0;
if(nums.size() == 1)return sum;
int k = 0;
int right = nums.size() - 1;
for(int i = 0;i < right;i++){
k = max(k,i + nums[i]);
if(k >= right){
sum++;
right = i;
i = -1;
k = 0;
}
}
return sum;
}
};
1005. K 次取反后最大化的数组和
给你一个整数数组 nums
和一个整数 k
,按以下方法修改该数组:
- 选择某个下标
i
并将nums[i]
替换为-nums[i]
。
重复这个过程恰好 k
次。可以多次选择同一个下标 i
。
以这种方式修改数组后,返回数组 可能的最大和 。
class Solution {
public:
int sum(vector<int>&nums){
int sum = 0;
for(int i = 0;i < nums.size();i++){
sum += nums[i];
}
return sum;
}
int largestSumAfterKNegations(vector<int>& nums, int k) {
sort(nums.begin(),nums.end());
if(nums[0] >= 0){
nums[0] *= pow(-1,k);
return sum(nums);
}
int i = 0;
for(;i < k && nums[i] < 0 && i < nums.size();i++){
nums[i] *= (-1);
}
if(k - i > 0){
sort(nums.begin(),nums.end());
nums[0] *= pow(-1,k - i);
}
return sum(nums);
}
};
134. 加油站
在一条环路上有 N 个加油站,其中第 i 个加油站有汽油 gas[i] 升。
你有一辆油箱容量无限的的汽车,从第 i 个加油站开往第 i+1 个加油站需要消耗汽油 cost[i] 升。你从其中的一个加油站出发,开始时油箱为空。
如果你可以绕环路行驶一周,则返回出发时加油站的编号,否则返回 -1。
class Solution {
public:
//暴力算法太慢,经常时间超出
int sum(vector<int>&num){
int sum = 0;
for(int i = 0;i < num.size();i++){
sum += num[i];
}
return sum;
}
int canCompleteCircuit(vector<int>& gas, vector<int>& cost) {
vector<int>cha(0,gas.size());
if(gas.size() == 1 && gas[0] - cost[0] >= 0)return 0;
for(int i = 0;i < gas.size();i++){
cha.push_back(gas[i] - cost[i]) ;
}
int sums = sum(cha);
int sum = 0;
int start = 0;
if(sums < 0)return -1;
else {
for(int i = 0;i < cha.size();i++){
sum += cha[i];
if(sum < 0){
start = i + 1;
sum = 0;
}
}
return start;
}
return -1;
}
};
135. 分发糖果
n
个孩子站成一排。给你一个整数数组 ratings
表示每个孩子的评分。
你需要按照以下要求,给这些孩子分发糖果:
- 每个孩子至少分配到
1
个糖果。 - 相邻两个孩子评分更高的孩子会获得更多的糖果。
请你给每个孩子分发糖果,计算并返回需要准备的 最少糖果数目 。
class Solution {
public:
int candy(vector<int>& ratings) {
vector<int>num(ratings.size(),1);//每个人糖果数量
for(int i = 1;i < ratings.size();i++){
if(ratings[i] > ratings[i - 1]){
num[i] = num[i - 1] + 1;
}
}
for(int i = ratings.size() - 2;i >= 0;i--){
if(ratings[i] > ratings[i + 1] && num[i] < (num[i + 1] + 1)){
num[i] = num[i + 1] + 1;
}
}
int sum = 0;
for(int i = 0;i < ratings.size();i++){
sum += num[i];
}
return sum;
}
};
860.柠檬水找零
在柠檬水摊上,每一杯柠檬水的售价为 5
美元。顾客排队购买你的产品,(按账单 bills
支付的顺序)一次购买一杯。
每位顾客只买一杯柠檬水,然后向你付 5
美元、10
美元或 20
美元。你必须给每个顾客正确找零,也就是说净交易是每位顾客向你支付 5
美元。
注意,一开始你手头没有任何零钱。
给你一个整数数组 bills
,其中 bills[i]
是第 i
位顾客付的账。如果你能给每位顾客正确找零,返回 true
,否则返回 false
。
class Solution {
public:
bool lemonadeChange(vector<int>& bills) {
int num5 = 0;//5元数量
int num10 = 0;//10元
for(int i = 0;i < bills.size();i++){
if(bills[i] == 5){
num5++;
}
else if(bills[i] == 10){
if(num5 > 0){
num5--;
num10++;
}
else{
return false;
}
}
else{
if(num5 > 0 && num10 > 0){
num10--;
num5--;
continue;
}
else if(num5 >= 3){
num5 = num5 - 3;
}
else{
return false;
}
}
}
return true;
}
};
*406. 根据身高重建队列
假设有打乱顺序的一群人站成一个队列,数组 people
表示队列中一些人的属性(不一定按顺序)。每个 people[i] = [hi, ki]
表示第 i
个人的身高为 hi
,前面 正好 有 ki
个身高大于或等于 hi
的人。
请你重新构造并返回输入数组 people
所表示的队列。返回的队列应该格式化为数组 queue
,其中 queue[j] = [hj, kj]
是队列中第 j
个人的属性(queue[0]
是排在队列前面的人)。
class Solution {
public:
//从高到低先排序,后面来插队**
//通过链表更快
static bool my_cmp(vector<int>v1,vector<int>v2){
if(v1[0] == v2[0])return v1[1] < v2[1];
return v1[0] > v2[0];
}
vector<vector<int>> reconstructQueue(vector<vector<int>>& people) {
vector<vector<int>>queue;
sort(people.begin(),people.end(),this->my_cmp);
if(people.size() == 1)return people;
for(int i = 0;i < people.size();i++){
queue.insert(queue.begin() + people[i][1],people[i]);//太巧妙l
}
return queue;
}
};
452. 用最少数量的箭引爆气球
有一些球形气球贴在一堵用 XY 平面表示的墙面上。墙面上的气球记录在整数数组 points
,其中points[i] = [xstart, xend]
表示水平直径在 xstart
和 xend
之间的气球。你不知道气球的确切 y 坐标。
一支弓箭可以沿着 x 轴从不同点 完全垂直 地射出。在坐标 x
处射出一支箭,若有一个气球的直径的开始和结束坐标为 x``start
,x``end
, 且满足 xstart ≤ x ≤ x``end
,则该气球会被 引爆 。可以射出的弓箭的数量 没有限制 。 弓箭一旦被射出之后,可以无限地前进。
给你一个数组 points
,返回引爆所有气球所必须射出的 最小 弓箭数 。
1
class Solution {
private:
static bool cmp(const vector<int>& a, const vector<int>& b) {
return a[0] < b[0];
}
public:
int findMinArrowShots(vector<vector<int>>& points) {
if (points.size() == 0) return 0;
sort(points.begin(), points.end(), cmp);
int result = 1; // points 不为空至少需要一支箭
for (int i = 1; i < points.size(); i++) {
if (points[i][0] > points[i - 1][1]) { // 气球i和气球i-1不挨着,注意这里不是>=
result++; // 需要一支箭
}
else { // 气球i和气球i-1挨着
points[i][1] = min(points[i - 1][1], points[i][1]); // 更新重叠气球最小右边界
}
}
return result;
}
};
2
class Solution {
public:
static bool cmp(vector<int>&v1,vector<int>&v2){
if(v1[0] == v2[0])return v1[1] < v2[1];
return v1[0] < v2[0];
}
int findMinArrowShots(vector<vector<int>>& points) {
sort(points.begin(),points.end(),cmp);
int start = points[0][0];
int end = points[0][1];
int sum = 1;
for(int i = 1;i < points.size();i++){
start = points[i][0];
if(points[i][0] <= end){
end = min(end,points[i][1]);
continue;
}
end = points[i][1];
sum++;
}
return sum;
}
};
435. 无重叠区间
给定一个区间的集合 intervals
,其中 intervals[i] = [starti, endi]
。返回 需要移除区间的最小数量,使剩余区间互不重叠 。
class Solution {
public:
static bool cmp(vector<int>&v1,vector<int>&v2){
if(v1[0] == v2[0])return v1[1] < v2[1];
return v1[0] < v2[0];
}
int eraseOverlapIntervals(vector<vector<int>>& intervals) {
if(intervals.size() == 1)return 0;
sort(intervals.begin(),intervals.end(),cmp);
int sum = 0;
for(int i = 1;i < intervals.size();i++){
if(intervals[i][0] < intervals[i - 1][1]){
intervals[i][1] = min(intervals[i][1],intervals[i - 1][1]);
sum++;
}
}
return sum;
}
};
763.划分字母区间
给你一个字符串 s
。我们要把这个字符串划分为尽可能多的片段,同一字母最多出现在一个片段中。
注意,划分结果需要满足:将所有划分结果按顺序连接,得到的字符串仍然是 s
。
返回一个表示每个字符串片段的长度的列表。
class Solution {
public:
vector<int> partitionLabels(string s) {
vector<int>v;
int sum = 1;
int start = 0;
for(int i = 0;i < s.size();i++){//也可以跟代码随想录一样自己造一个最后出现位置
if(sum == 1 && s.find_last_of(s[i]) < i + 1){
v.push_back(1);
start = i + 1;
}
else if(sum == 1 && s.find_last_of(s[i]) >= i + 1){
sum += s.find_last_of(s[i]);
}
else if(sum != 1 && s.find_last_of(s[i]) >= sum && i < sum - 1){
sum += (s.find_last_of(s[i]) - sum + 1);
}
else if(i == sum - 1){
int val = sum - start;
v.push_back(val);
sum = 1;
start = i + 1;
}
}
return v;
}
};
56. 合并区间
以数组 intervals
表示若干个区间的集合,其中单个区间为 intervals[i] = [starti, endi]
。请你合并所有重叠的区间,并返回 一个不重叠的区间数组,该数组需恰好覆盖输入中的所有区间 。
class Solution {
public:
static bool cmp(vector<int>&v1,vector<int>&v2){
if(v1[0] == v2[0])return v1[1] < v2[1];
return v1[0] < v2[0];
}
vector<vector<int>> merge(vector<vector<int>>& intervals) {
vector<vector<int>> merge;
vector<int>v = {-1,-1};
if(intervals.size() == 1)return intervals;
sort(intervals.begin(),intervals.end(),cmp);
v[0] = intervals[0][0];
for(int i = 1;i < intervals.size();i++){
if(intervals[i][0] > intervals[i - 1][1]){
v[1] = intervals[i - 1][1];
merge.push_back(v);
v[0] = intervals[i][0];
}
else intervals[i][1] = max(intervals[i - 1][1],intervals[i][1]);
}
v[1] = intervals[intervals.size() - 1][1];
merge.push_back(v);
return merge;
}
};
738.单调递增的数字
当且仅当每个相邻位数上的数字 x
和 y
满足 x <= y
时,我们称这个整数是单调递增的。
给定一个整数 n
,返回 小于或等于 n
的最大数字,且数字呈 单调递增 。
class Solution {
public:
int monotoneIncreasingDigits(int n) {
if(n < 20 && n != 10)return n;
if(n == 10)return 9;
vector<int>v;
while(n){
v.push_back(n % 10);
n /= 10;
}
int j = -1;
for(int i = 0;i < v.size() - 1;i++){
if(v[i] < v[i + 1]){
j = i;
v[i + 1]--;
}
}
int sum = 0;
for(int i = 0;i < v.size();i++){
if(i <= j){
sum += 9 * pow(10,i);
}
else sum += v[i] * pow(10,i);
}
return sum;
}
};
*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 {
// 0:什么都没有
// 1:被覆盖
// 2:有摄像头
//看代码随想录的
public:
int travel(TreeNode* root,int &sum){
if(root == nullptr)return 1;
int left = travel(root->left,sum);
int right = travel(root->right,sum);
if(left == 1 && right == 1){
return 0;
}
if(left == 0 || right == 0){
sum++;
return 2;
}
if(left == 2 || right == 2){
return 1;
}
return 0;
}
int minCameraCover(TreeNode* root) {
int sum = 0;
if(travel(root,sum) == 0){
sum++;
}
return sum;
}
};