贪心算法：分饼干

贪心的本质是选择每一阶段的局部最优，从而达到全局最优。

分发饼干

对待 先用大的喂饱大胃口：先遍历胃口，再遍历饼干。

固定最大的饼干不浪费，如果这个胃口满足不了，就换下一个小点的胃口。

• 代码逻辑（先胃口，后饼干）：

  cpp

  for (int i = 0; i < g.size(); i++) { // 遍历胃口（从大到小）
      if (j < s.size() && s[j] >= g[i]) { // 如果当前最大饼干够用
          j++; // 饼干用掉，指针后移
          count++;
      }
      // 如果最大饼干不够用，这块饼干就等着看下一个较小的胃口
  }

• 为什么这么走？

  因为最大的饼干是"王牌"。如果最大的饼干连当前最大的胃口都喂不饱，那这个最大的胃口就永远没戏了（因为其他饼干更小），直接放弃这个胃口，去看下一个稍微小一点的胃口。

  比如胃口 [10, 9]，饼干 [8]。最大饼干 8 喂不饱 10，放弃 10，去看 9，发现 8 还是不够，最终一个都喂不饱。先看胃口，是为了判断"王牌饼干还有没有用"。

对待 先用小的喂饱小胃口：先遍历饼干，再遍历胃口。

• 代码逻辑（先饼干，后胃口）：

  cpp

  for (int i = 0; i < s.size(); i++) { // 遍历饼干（从小到大）
      if (j < g.size() && s[i] >= g[j]) { // 如果当前最小饼干能喂饱当前最小胃口
          j++; // 胃口满足了，看下一个胃口
          count++;
      }
      // 如果最小饼干连最小胃口都喂不饱，这块饼干就是废铁，直接扔掉看下一块大点的饼干
  }

• 为什么这么走？

  因为最小的饼干是最"鸡肋"的。如果最小的饼干连当前最小的胃口都喂不饱，那它肯定也喂不饱后面更大的胃口，所以直接跳过这块饼干（浪费掉） ，看下一块大一点的饼干。

  比如胃口 [2, 3]，饼干 [1, 4]。最小饼干 1 喂不饱最小胃口 2，直接扔掉 1（i++）；看饼干 4，能喂饱胃口 2，成功。先看饼干，是为了判断"鸡肋饼干还能不能抢救一下"。

代码bug问题：

class Solution {
public:
    int findContentChildren(vector<int>& g, vector<int>& s) {
        sort(g.begin(),g.end());
        sort(s.begin(),s.end());
        int index=0;
        int res=0;
        for(int i=0;i<=s.size()-1;i++){
            if(s[i]>=g[index]&&index<=g.size()-1){//这一行是错的，原因如下×
                index++;
                res++;
            }
        }
        
        return res;
    }
};

错误 1：循环条件 i <= s.size() - 1 在 s.size() == 0 时崩溃

当 s 为空时，s.size() 返回 0，s.size() - 1 是无符号整数下溢（变成 18446744073709551615），循环会执行几十亿次，疯狂越界访问。

修正 ：使用 for (int i = 0; i < s.size(); i++)，这样当 s.size() == 0 时循环体不会执行。

---

🚨 错误 2：访问 g[index] 之前没有检查 index 是否越界

在 if 条件中，你写的是：

cpp

if (s[i] >= g[index] && index <= g.size() - 1)

这里 先 计算了 g[index]，后 检查 index <= g.size() - 1。当 index 已经等于 g.size() 时，g[index] 直接越界，程序崩溃。