LeetCode | 贪心算法

12.13 455.

假设你是一位很棒的家长，想要给你的孩子们一些小饼干。但是，每个孩子最多只能给一块饼干。
对每个孩子 i，都有一个胃口值 g[i]，这是能让孩子们满足胃口的饼干的最小尺寸；并且每块饼干 j，都有一个尺寸 s[j] 。如果 s[j] >= g[i]，我们可以将这个饼干 j 分配给孩子 i ，这个孩子会得到满足。你的目标是尽可能满足越多数量的孩子，并输出这个最大数值。

示例 1:

输入: g = [1,2,3], s = [1,1]
输出: 1
解释:
你有三个孩子和两块小饼干，3个孩子的胃口值分别是：1,2,3。
虽然你有两块小饼干，由于他们的尺寸都是1，你只能让胃口值是1的孩子满足。
所以你应该输出1。

示例 2:

输入: g = [1,2], s = [1,2,3]
输出: 2
解释:
你有两个孩子和三块小饼干，2个孩子的胃口值分别是1,2。
你拥有的饼干数量和尺寸都足以让所有孩子满足。
所以你应该输出2.

代码：

class Solution {
public:
    int findContentChildren(vector<int>& g, vector<int>& s) {
        sort(g.begin(),g.end()) ;
        sort(s.begin(),s.end());
        int g1=0,s1=0;
        while(g1<g.size()&&s1<s.size()){
            if(g[g1]<=s[s1]) ++g1;
            ++s1;
        }
        return g1; 
    }
};

贪心算法：排序；以需求为准，优先满足最好满足的

vector总结：

头文件：#include<vector>
记住：using namespace std;
定义：
1.vector<int>g;vector<int>& g;

2.vector<T>v3(n,val) //v3中有n个重复的元素，每个元素的值都是val

3.int arr[5]={1,2,3,4,5};
  vector<int>v5(arr,&arr[5]);//以区间[beg;end)做为初值的vector；
                             //另arr可以写成&arr[0]

输入：g.push_back();

排序：sort（g.begin(),g.end()）;

输出：for（int i=0；i<g.size()；i++）{
	cout<<g[i];
}

accumulate总结：

头文件：#include<numeric>//数值计算库
对vector累加求和
1.int sum = accumulate(vec.begin() , vec.end() , 42);//42为起始值
2.string sum = accumulate(v.begin() , v.end() , string(" "));//空格为起始值

12.15 135.

老师想给孩子们分发糖果，有 N 个孩子站成了一条直线，老师会根据每个孩子的表现，预先给他们评分。

你需要按照以下要求，帮助老师给这些孩子分发糖果：

每个孩子至少分配到 1 个糖果。
相邻的孩子中，评分高的孩子必须获得更多的糖果。

那么这样下来，老师至少需要准备多少颗糖果呢？

示例 1:

输入: [1,0,2]
输出: 5
解释: 你可以分别给这三个孩子分发 2、1、2 颗糖果。

示例 2:

输入: [1,2,2]
输出: 4
解释: 你可以分别给这三个孩子分发 1、2、1 颗糖果。
第三个孩子只得到 1 颗糖果，这已满足上述两个条件。

代码：

class Solution {
public:
    int candy(vector<int>& ratings) {
        int size=ratings.size();
        if(size<2){
            return size;
        }
        
        vector<int>num(size,1);
        
        for(int i=1;i<size;++i){
            if(ratings[i-1]<ratings[i]){
                num[i]=num[i-1]+1;
            }
        }
        for(int i=size-1;i>0;--i){
            if(ratings[i-1]>ratings[i]){
                num[i-1]=max(num[i-1],num[i]+1);
            }
        }
        return accumulate(num.begin(),num.end(),0);
    }
};

贪心算法：左右各一次遍历，取局部最优。

for循环里，因为是比较，不是读取，i从1开始。

++i 和 i++ 区别在于：++i 返回加1之后的值，i++返回之前的值。

12.21 435.

给定一个区间的集合，找到需要移除区间的最小数量，使剩余区间互不重叠。

注意:

可以认为区间的终点总是大于它的起点。
区间 [1,2] 和 [2,3] 的边界相互“接触”，但没有相互重叠。

示例 1:

输入: [ [1,2], [2,3], [3,4], [1,3] ]

输出: 1

解释: 移除 [1,3] 后，剩下的区间没有重叠。

示例 2:

输入: [ [1,2], [1,2], [1,2] ]

输出: 2

解释: 你需要移除两个 [1,2] 来使剩下的区间没有重叠。

示例 3:

输入: [ [1,2], [2,3] ]

输出: 0

解释: 你不需要移除任何区间，因为它们已经是无重叠的了。

代码：

class Solution {
public:
    int eraseOverlapIntervals(vector<vector<int>>& intervals) {
        if(intervals.empty()){
            return 0;
        }
        int n=intervals.size();
        sort(intervals.begin(),intervals.end(),[](vector<int>a,vector<int>b){return a[1]<b[1];});
        int total=0,prev=intervals[0][1];
        for(int i=1;i<n;++i){
            if(intervals[i][0]<prev){
                ++total;
            }else{
                prev=intervals[i][1];
            }
        }
    return total;
    }
};

贪心算法：排序，要移除的区间数量最小，就把大的区间扔掉。

sort补充：

与lambda连用：sort(intervals.begin(),intervals.end(),[](vector<int>a,vector<int>b){return a[1]<b[1];});

lambda用法：

vector<Student> students = {{2,"li lei"}, {1,"zhang jun"}, {4, "wang lei"}};
    sort(students.begin(), students.end(), [](Student& a, Student& b) -> bool {
        return a.ID < b.ID;
    });

return前多了一个 -> ，多了一个bool声明。

下面是一个合法的Lambda表达式：

[=] (int x, int y) -> bool {return x%10 < y%10; }；

Lambda 表达式的定义形式如下：

[外部变量访问方式说明符] (参数表) -> 返回值类型
{
   语句块
}

其中，“外部变量访问方式说明符”可以是=或&，表示{}中用到的、定义在{}外面的变量在{}中是否允许被改变。=表示不允许，&表示允许。当然，在{}中也可以不使用定义在外面的变量。“-> 返回值类型”可以省略。