数据算法---贪心算法

算法核心思想
采用贪心的策略，保证每次操作都是局部最优的，最终达到全局最优。

分配问题
455. Assign Cookies (Easy)

题目描述

有一群孩子和一堆饼干，每个孩子有一个饥饿度，每个饼干都有一个大小。每个孩子只能吃
最多一个饼干，且只有饼干的大小大于孩子的饥饿度时，这个孩子才能吃饱。求解最多有多少孩
子可以吃饱。

输入输出样例

输入两个数组，分别代表孩子的饥饿度和饼干的大小。输出最多有多少孩子可以吃饱的数
量。
Input: [1,2], [1,2,3]
Output: 2

思路：在这个样例中，我们可以给两个孩子喂 [1,2]、 [1,3]、 [2,3] 这三种组合的任意一种。
分配问题先对物资和分配的对象进行排序，由于饥饿度小的孩子最容易满足，所以用尽量小的饼干满足饥饿度最小的孩子，然后采用同样的策略直到无法满足。

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

/*
vector<int>  g孩子胃口   s size
if s[j]>g[i] 
sort s,g
for(i=0;i< ;i++)
{
    for(j=i;j< ;j++)
    {
        if(s[j]>g[i])
        {
            sum++;
            break;
        }
    }
}

while(i<i.size&& j<j.sizew)
{
    
     if(s[j]>g[i])
        {
            i++;
        }
        j++;
}
return i;


Sort函数有三个参数：

第一个是要排序的数组的起始地址。
第二个是结束的地址（最后一位要排序的地址）
第三个参数是排序的方法，可以是从大到小也可是从小到大，还可以不写第三个参数，此时默认的排序方法是从小到大排序。



*/
//对两个数组排序后，给剩余孩子里最小饥饿度的孩子分配最小的能饱腹的饼干。
class Solution {
public:
    int findContentChildren(vector<int>& g, vector<int>& s)
    {
        sort(g.begin(), g.end());
        sort(s.begin(), s.end());
        int i = 0;
        int j = 0; 

        while (i < g.size() && j < s.size())
        {

            if (s[j] >= g[i])
            {
                i++; 
                j++;
            }
            else
            {
                j++;
            }
         
        }
        return i;

    }
};

int main()
{
    vector<int> g{ 3,2,2,0 };
    vector<int> s{ 1,3,3,10 };

    Solution sol;
   int fin= sol.findContentChildren(g, s);
   cout << " final =" << fin << endl;

}

135. Candy (Hard)

题目描述

一群孩子站成一排，每一个孩子有自己的评分。现在需要给这些孩子发糖果，规则是如果一
个孩子的评分比自己身旁的一个孩子要高，那么这个孩子就必须得到比身旁孩子更多的糖果；所
有孩子至少要有一个糖果。求解最少需要多少个糖果。

输入输出样例

输入是一个数组，表示孩子的评分。输出是最少糖果的数量。
Input: [1,0,2]
Output: 5
在这个样例中，最少的糖果分法是 [2,1,2]。

思路：这个分配问题不好进行排序，这里先全部初始化为1，再将规则分为左规则和右规则，当每个孩子既满足左规则又满足右规则时就会满足条件。第一次遍历用来满足左规则，第二次遍历用来满足右规则（第二次遍历可能已经满足右规则，要先检验）。

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


//将题目要求分为左规则和右规则，先满足左规则，再检验右规则
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 j = ratings.size() - 1; j > 0; j--)
        {
            if (ratings[j]< ratings[j - 1])
            {
                num[j - 1] = max(num[j - 1], num[j] + 1);//从右向左遍历时，如果左边评分比右边高且左边的糖果数不大于右边的，则左边孩子的糖果数更新为右边加1
            }
        }




        return accumulate(num.begin(), num.end(),0);



    }
};


int main()
{
    vector<int> ratings{ 1,3,4,5,2 };

    Solution s;
    int count = s.candy(ratings);
    cout << "count = " << count << endl;
}

区间问题
435. Non-overlapping Intervals (Medium)

题目描述

给定多个区间，计算让这些区间互不重叠所需要移除区间的最少个数。起止相连不算重叠。

输入输出样例

输入是一个数组，数组由多个长度固定为 2 的数组组成，表示区间的开始和结尾。输出一个
整数，表示需要移除的区间数量。
Input: [[1,2], [2,4], [1,3]]
Output: 1
在这个样例中，我们可以移除区间 [1,3]，使得剩余的区间 [[1,2], [2,4]] 互不重叠。

思路：这个区间问题顺序没有影响，故可以先进行排序，这里的贪心策略认为区间结尾最小的区间更有利于留给后面的区间更多的空间。所以先按照区间结尾的大小进行排序，然后优先保留结尾小且不相交的区间。

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

//按右端点的大小排序
//先找到右端点最小的区间作为首个区间，再找下一个与前一个区间不重合的右端点最小的区间
bool compare(vector<int>a, vector<int>b)
{
    return  a[1] < b[1];
}
class Solution
{
public:
    int eraseOverlapIntervals(vector<vector<int>>& intervals)
    {

        sort(intervals.begin(), intervals.end(), compare);
        int end = intervals[0][1];
        int count = 1;
        for (int i = 0; i < intervals.size(); i++)
        {
            if (intervals[i][0] >= end)
            {
                count++;
                end = intervals[i][1];
            }
            
        }
        return intervals.size()-count;

    }

   


};


int main()
{
    vector<vector<int>>a{ {1,2},{2,4},{1,3} };
    Solution s;
    int final=s.eraseOverlapIntervals(a);
    cout << "final =" << final << endl;
}