[Vssue]0455.分发饼干.md

[youngyangyang04]

https://www.programmercarl.com/0455.%E5%88%86%E5%8F%91%E9%A5%BC%E5%B9%B2.html

[HALF111]

这里小饼干优先喂给小胃口的孩子应该也是可以的~

[Du1in9]

class Solution {
    public int findContentChildren(int[] g, int[] s) {
        Arrays.sort(s);
        Arrays.sort(g);
        int i = s.length - 1;
        int count = 0;
        for(int j = g.length - 1; j >= 0; j--){
            if(i >= 0 && s[i] >= g[j]){
                count++;
                i--;
            }
        }
        return count;
    }
}

[SEUZTh]

Java代码里count变量多余了

[ZYKWLJ]

补充一下卡尔哥哥的说法，可以使用先遍历饼干，这里我的理解是这样的，用if控制饼干一定被消费了才-1。后面的胃口一定-1，因为大了就直接-1减小胃口，小了直接符合也要减一，终止条件是两者有其一小于0即可。

​ class Solution { public int findContentChildren(int[] g, int[] s) { // s 饼干 // g 胃口 Arrays.sort(g); Arrays.sort(s); int i=s.length-1; int j=g.length-1; int result=0; while(i>=0&&j>=0){ if(j>=0&&s[i]>=g[j]){ result++; i--; //饼干被消费了才会递减
} j--; //胃口每遍历一次一定要减一，小的直接满足了，大的就直接跳过 } return result; } }

[ZYKWLJ]

class Solution { public int findContentChildren(int[] g, int[] s) { // 升序算法 // return findMaxByIncreaseing(g,s); // 降序算法 return findMaxByDecreaseing(g,s); } 升降序两种算法，请君指正

public int findMaxByIncreaseing(int[] g,int[] s){
        // s 饼干 
        // g 胃口
        // 假定是升序
        // 显然贪心思维，大饼干喂大胃口，一直往下走，以饼干为外循环，胃口为里面的条件判断即可，每次循环饼干肯定递减，但是胃口只有遇到了大于自己的饼干才递减。
        // 遇见数组就要看有没有排序，自己的逻辑需不需要有序?题目没说是不是有序的，这里一定要排序，因为题目的逻辑就是建立在递增的逻辑之上的
        Arrays.sort(g);
        Arrays.sort(s);
        int result=0;
        int len_g=g.length-1;
        int len_s=s.length-1;
        // 本来就只要遍历一次就OK的，所以只需要有一个循环，至于里面的if条件判断，是另外一回事
        while(len_g>=0&&len_s>=0){
            // while(len_g>=0&&len_s>=0&&s[len_s]>=g[len_g]){
            if(len_g>=0&&len_s>=0&&s[len_s]>=g[len_g]){
                result++;
                len_s--;
            };
            len_g--;
        };
        return result;
}

    public int findMaxByDecreaseing(int[] g,int[] s){
        // s 饼干 
        // g 胃口
        // 假定是降序

        // 显然贪心思维，小胃口吃小饼干，一直往下走，以胃口为外循环，饼干为里面的条件判断即可，每次饼干肯定递减(换成更大的)，但是胃口只有在小于当饼干时才递减。
        // 遇见数组就要看有没有排\降序，自己的逻辑需不需要有序?题目没说是不是有序的，这里一定要排序，因为题目的逻辑就是建立在递增的逻辑之上的
        // 这里利用降序排序
        // 由于这个sort传入的lamabd是对象类型，int类型不符合了，这里直接使用Stream来降序会更好、。
        // Arrays.sort(g,(a,b)->b-a);
        // Arrays.sort(s,(a,b)->b-a);
       g=Arrays.stream(g)
                      .boxed()
                      .sorted((a, b) -> b - a)
                      .mapToInt(Integer::intValue)
                      .toArray();
        s=Arrays.stream(s)
                      .boxed()
                      .sorted((a, b) -> b - a)
                      .mapToInt(Integer::intValue)
                      .toArray();
        int result=0;
        int len_g=g.length-1;
        int len_s=s.length-1;
        // 本来就只要遍历一次就OK的，所以只需要有一个循环，至于里面的if条件判断，是另外一回事
        while(len_g>=0&&len_s>=0){
            if(len_g>=0&&len_s>=0&&s[len_s]>=g[len_g]){
                result++;
                len_g--;
            };
            len_s--;
        };
        return result;
}
}