贪心算法,算法贪心算法
贪婪算法(指派问题):455。分配饼干分配器：标题：有一群孩子和一堆饼干。每个孩子都有饥饿程度，每个饼干都有大小。每个孩子只能吃一块饼干，只有饼干的大小不小于孩子的饥饿感，孩子才能吃饱。
找出孩子最多能吃多少。
思考：一个孩子只能吃一块饼干。只有饼干大小=饥饿程度，他才能吃饱。
输入：
饥饿：[1，2]
Cookie大小：[1，2，3]
输出：
2
因此，没有提供cookie重用，也就是说，大小为3的cookie只能由一个孩子吃，而不是[1，1，1]可以吃一个cookie。
排序，孩子会自己满足，饼干每次都会增加。经过排序，孩子的饥饿感从小到大。如果饼干不能满足孩子，就意味着永远不能满足下一个孩子，所以饼干每次都会增加。
延伸思维：现实商业中估计没有，产品和原则不会同意浪费资源。哈哈，给自己提个要求吧。本着节约的原则，如果饼干可以一起吃呢？
改变游戏规则：
三个孩子的饥饿感是1，1，1，大小为3的饼干可以满足三个孩子。孩子饿了2，3，如果大小是4，被这个孩子吃了还剩下2，下一个孩子的饥饿程度是3，那么2就浪费了。浪费的饼干堆积起来需要养活后面撞上的孩子。总之不能浪费饼干。
解决问题：你可以把饥饿感加起来，比较饼干的大小。如果总的cookie大小是饥饿的，那么它们都将被满足，但是这将浪费累积计算。有序排序需要添加一些业务条件。原来的条件是=，现在区分条件==并匹配临时变量的差。
代码：#包含iostream
#包含矢量
#包含算法
int findcontentchildren 1(STD:vector int children，STD:vector int cookie)
{
std:sort(children.begin()、children . end())；
std:sort(cookies.begin()，cookies . end())；
int child=0，cookie=0；
//累计浪费了多少cookie大小
int food=0；
while(child children . size()cookie cookies . size())
{
做{
如果(食物)
{
//浪费饼干。一块饼干比一个孩子的饥饿还要大
if (children[child](食物饼干[cookie])
{
food=(food cookie[cookie])-children[child]；
打破；
}
//浪费饼干一块饼干来抵消孩子的饥饿
else if (children[child]==(食品饼干[cookie]))
打破；
}
//如果饥饿和饼干大小相等，偏移
if(children[child]==cookie[cookie])
打破；
//如果饥饿小于cookie大小，求差_累加
else if(children[child]cookie[cookie])
{
//在这里，食物堆积了废弃的饼干。
food=cookies[cookie]-children[child]；
}
//食物一块饼干不能满足一个孩子的饥饿。
其他
{
//因为while out to child，这里是第一个-，相当于同一个child。
子-；
食物=饼干[曲奇]；
}
} while(假)；
孩子；
曲奇；
}
//已经知道几个孩子吃饱了，需要判断食物是否有食物(饼干)库存。
while (child children.size())
{
//
(食品儿童[儿童])？(food-=children[child]):(food=0)；
if (food==0)
打破；
孩子；
}
返回孩子；
}
int main(void)
{
std:vector int children={ 1，1，0，3，3，2，2 }；
STD:vector int cookie={ 0，0，0，10，1，2 }；
findContentChildren1(孩子，cookies
}
LeetCode Github见2.2:https://github.com/changgyhub/leetcode_101/
LeetCode参见：https://leetcode.com/problems/assign-cookies/
135.糖果话题：一群孩子站成一排，每个孩子都有自己的年级。
现在我们需要给这些孩子糖果。规则是，如果一个孩子的分数比他旁边的孩子高，那么这个孩子得到的糖果必须比他旁边的孩子多；
所有的孩子都应该至少有一颗糖果。解决所需糖果的最小数量。
输入代表孩子评分的数组。
产量是最少的糖果。
输入：[1，0，2]
输出：5
第一次，代码编写如下。对于排序，你只需要判断左边的元素大于右边的元素，那么糖果就可以增加。看了分析，你理解错了问题的意思，你需要明白重要性。
const int GetCoutCandy(STD:vector int children)
{
int candy cout=children . size()；
if (children.size() 2) {
返回candycout
}
std:sort(children.begin()、children . end())；
size _ t idx=0；
const size _ t loop idx=children . size()；
for(；idx loopidxidx)
{
//最后一个元素
if ((loopidx - idx)==1)
打破；
if(儿童[idx 1]儿童[idx])
candycout
}
返回candycout
}
乱序和左右来比较，所有孩子的糖果号都初始化为1；首先从左向右遍历。如果右孩子的分数高于左孩子的分数，则将右孩子的糖果数更新为左孩子的糖果数加1；再次从右向左遍历。如果左孩子的分数高于右孩子的分数，并且左孩子的当前糖果数不大于右孩子的糖果数，则将左孩子的糖果数更新为右孩子的糖果数加1。
PDF的代码：
int candy(标准：矢量int ratings) {
int size=ratings . size()；
如果(尺寸2) {
返回大小；
}
std:vector int num(size，1)；
for(int I=1；I尺寸；i) {
if (ratings[i] ratings[i - 1]) {
num[I]=num[I-1]1；
}
}
for(int I=size-1；我-我){
if (ratings[i] ratings[i - 1]) {
num[i - 1]=max(num[i - 1]，num[I]1)；
}
}
//std:accumulate可以轻松求和。
return accumulate(num.begin()，num.end()，0)；
}
延伸思维：规则是，如果当前儿童的价值观大于左右儿童的价值观，则增加糖果的数量，如：
输入：[1，2，1]
输出：5
因为它比左右两边都大，所以它得到了两颗糖果。
代码：consint getcoutcandy 1(STD:vector int children)
{
int candy cout=children . size()；
if (children.size() 2) {
返回candycout
}
size _ t idx=0；
const size _ t loop idx=children . size()；
for(；idx loopidxidx)
{
//顺序应该是正确的。先判断是否==1，否则出界。
if ((loopidx - idx)==1)
{//数组的最后一个元素，只做左边的比较，因为是最右边的元素。
if(儿童[idx]儿童[idx - 1])
candycout
}
else if (idx！=0)
{
if(儿童[idx]儿童[idx 1])
candycout
if(儿童[idx]儿童[idx - 1])
candycout
}
其他
{//数组的第一个元素，只比较右边的，因为是最左边的元素。
if(儿童[idx]儿童[idx 1])
candycout
}
；
}
返回candycout
}
LeetCode Github见2.2:https://github.com/changgyhub/leetcode_101/
LeetCode参见：https://leetcode.com/problems/candy/
来自慢，慢。
郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。