azl397985856 commented 2 years ago

455. 分发饼干

入选理由

暂无

题目地址

https://leetcode-cn.com/problems/assign-cookies/

前置知识

暂无

题目描述

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

注意：

你可以假设胃口值为正。
一个小朋友最多只能拥有一块饼干。

示例 1:

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

输出: 1

解释:

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

示例 2:

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

输出: 2

解释:

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

yanglr commented 2 years ago

思路:

贪心。

方法: 贪心 + 双指针

贪心思想: 尽可能多地让最小的饼干满足胃口小一点的小孩, 刚刚满足小孩的胃口即可, 也就是让饼干最大可能地被利用~

先排序, 然后用指针i 遍历s数组, 接下来到g数组中找(j指针从0开始)。

发现1组满足条件的, 就把j 移动1位。

循环结束时, 返回 j。

不要把问题想复杂了。

代码:

实现语言: C++

class Solution {
public:
    int findContentChildren(vector<int>& g, vector<int>& s) {
        sort(g.begin(), g.end());
        sort(s.begin(), s.end());
        // 双指针
        int j = 0;  // 遇到满足条件的情形, j才移动一步(同时是一个计数器)      
        for (int i = 0; i < s.size() && j < g.size(); ++i)
        {
            if (s[i] >= g[j]) j++;
        }
        return j;
    }
};

复杂度分析:

时间复杂度: O(n * log n)
空间复杂度: O(1)

chang-you commented 2 years ago

class Solution {
    public int findContentChildren(int[] g, int[] s) {
        int res = 0;
        Arrays.sort(g);
        Arrays.sort(s);
        int i = 0, j = 0;
        while (i < g.length && j < s.length) {
            if (g[i] <= s[j]) {
                res++;
                i++;
                j++;
            } else if (g[i] > s[j]) {
                j++;
            }
        }
        return res;

    }
}

pan-qin commented 2 years ago

Idea:

greedy. Sort the array of child and array of cookies. If the current cookie can satisfy the child, move on to next cookie and next child. Otherwise, check if next cookie can satisfy this child.

Complexity:

Time: O(nlogn) Space: O(1)

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

    }
}

chenming-cao commented 2 years ago

解题思路

贪心。我们只能把不小于孩子胃口值的饼干给孩子，并且每块饼干最多只能给1个孩子。我们可以分别对孩子们按胃口值从小到大排序，对饼干按尺寸从小到大排序，将排好序的两个数组同时向后遍历，优先满足胃口值小的孩子。最后返回结果即可。

代码

class Solution {
    public int findContentChildren(int[] g, int[] s) {
        // sort g and s, easy to compare
        Arrays.sort(g);
        Arrays.sort(s);
        int gidx = 0, sidx = 0;
        int res = 0;
        while (gidx < g.length && sidx < s.length) {
            // we can assign the cookie
            if (g[gidx] <= s[sidx]) {
                res++;
                gidx++;
                sidx++;
            }
            // we cannot assign the cookie, check next cookie
            else {
                sidx++;
            }
        }
        return res;
    }
}

复杂度分析

时间复杂度：O(nlogn)，因为要排序
空间复杂度：O(1)

yibenxiao commented 2 years ago

【Day 65】455. 分发饼干

思路

比较两个数组

代码

class Solution {
public:
    int findContentChildren(vector<int>& g, vector<int>& s) {
        int sum=0;
        int lenG=g.size(),lenS=s.size();
        sort(g.begin(),g.end());
        sort(s.begin(),s.end());
        int i=0,j=0;
        while(i<lenG && j<lenS)
        {
            if(g[i]<=s[j])
            {
                sum+=1;
                i+=1;
            }
            j+=1;
        }
        return sum;
    }
};

复杂度

时间复杂度：O(NLogN)

空间复杂度：O(1)

thinkfurther commented 2 years ago

思路

从大到小遍历孩子，选择最大的饼干，直到结束

代码

class Solution:
    def findContentChildren(self, g: List[int], s: List[int]) -> int:
        g.sort(reverse = True)
        s.sort(reverse = True)

        s_index = 0

        result = 0

        for g_index, g_value in enumerate(g):
            if s_index >= len(s):
                break

            if s[s_index] < g_value:
                continue

            result += 1
            s_index += 1

        return result

代码

时间复杂度：O(N*logN)

空间复杂度：O(1)

zhy3213 commented 2 years ago

思路

贪心双指针

代码

    def findContentChildren(self, g: List[int], s: List[int]) -> int:
        if not s:
            return 0
        g.sort()
        s.sort()
        offset,index=0,0
        while index+offset<len(s) and index<len(g):
            if s[index+offset]<g[index]:
                while s[index+offset]<g[index]:
                    offset+=1
                    if index+offset==len(s):
                        return index
            index+=1
        return index

biancaone commented 2 years ago

class Solution:
    def findContentChildren(self, g: List[int], s: List[int]) -> int:
        if not g or not s:
            return 0
        g.sort()
        s.sort()

        result, g_l, s_l = 0, 0, 0

        while g_l < len(g) and s_l < len(s):
            if g[g_l] <= s[s_l]:
                result += 1
                g_l += 1
                s_l += 1
            else:
                s_l += 1

        return result

banjingking commented 2 years ago

思路

two pointer + greedy

代码

class Solution {
  public int findContentChildren(int[] g, int[] s) {
    Arrays.sort(g);
    Arrays.sort(s);
    int i = 0; // pointer for children
    int j = 0; // pointer for cookies
    while(i < g.length && j < s.length) {
      if(s[j] >= g[i]) {
        i++;
        j++;
      } else {
        j++;
      }
    }
    return i;
  }
}

Time complexity

空间复杂度: O(1)

时间复杂度: O(nlogn)

zhuzuojun commented 2 years ago

class Solution {
    public int findContentChildren(int[] g, int[] s) {
        // 尽量用小的饼干满足小孩
        Arrays.sort(g);
        Arrays.sort(s);
        int j = 0; // 被满足小孩的个数
        for (int i = 0; i < s.length && j < g.length; i++) {
            if (s[i] >= g[j]) {
                j += 1;
            }
        }
        return j;
    }
}

zhangzz2015 commented 2 years ago

思路

对饼干数以及孩子的需求进行排序，优先满足最小需求的孩子，可满足更多的孩子，因为如果需求少的孩子没法满足，需求更多的孩子肯定无法满足。时间复杂度为O(nlogn + mlogm + max(n,m)) 空间复杂度为O(1)，取决于排序算法是否用in place方法。

关键点

代码

语言支持：c

c Code:


class Solution {
public:
    int findContentChildren(vector<int>& g, vector<int>& s) {

        sort(g.begin(), g.end()); 
        sort(s.begin(), s.end()); 

        int gleft =0; 
        int sleft =0; 

        int count =0; 
        while(gleft< g.size() && sleft< s.size())
        {

            if(g[gleft]<=s[sleft])
            {
                count++; 
                gleft++; 
                sleft++; 
            }
            else
                sleft++;
        }

        return count; 

    }
};

ginnydyy commented 2 years ago

Problem

https://leetcode.com/problems/assign-cookies/

Notes

Greedy
Two pointers are used to point to each array, consider the child with least greedy factor first, and try the smallest cookie first.

Solution

class Solution {
    public int findContentChildren(int[] g, int[] s) {
        if(g == null || s == null){
            return 0;
        }

        int res = 0;
        Arrays.sort(g);
        Arrays.sort(s);

        int i = 0;
        int j = 0;
        while(i < g.length && j < s.length){
            while(j < s.length && s[j] < g[i]){
                j++;
            }
            if(j < s.length && s[j] >= g[i]){
                res++;
                i++;
                j++;
            }
        }

        return res;
    }
}

Complexity

Time: O(nlogn + mlogm), n and m is the length of the two arrays respectively. Sorting two arrays cost O(nlogn + mlogm). All the elements in the arrays are visited at most once, each visit costs O(1). Overall O(nlogn + mlogm).
Space: It depends on the sorting algorithm.

florenzliu commented 2 years ago

Explanation

greedy approach
- sorting both arrays: when there is a pair satisfying the condition, count + 1; otherwise, skip the current child

Python

class Solution:
    def findContentChildren(self, g: List[int], s: List[int]) -> int:
        s.sort(reverse=True)
        g.sort(reverse=True)
        gi, si = 0, 0
        count = 0
        while gi < len(g) and si < len(s):
            if s[si] >= g[gi]:
                count += 1
                si += 1
            gi += 1
        return count

Complexity:

Time Complexity: O(nlogn) where n is max(len(g), len(s))
Space Complexity: O(1)

heyqz commented 2 years ago

class Solution:
    def findContentChildren(self, g: List[int], s: List[int]) -> int:
        g.sort()
        s.sort()

        child = 0
        cookie = 0
        while child < len(g) and cookie < len(s):
            if g[child] <= s[cookie]:
                child += 1
            cookie += 1
        return child

time complexity: O(nlogn) space complexity: O(1)

JiangyanLiNEU commented 2 years ago

Idea

sort both array and assign from greatest to smallest

Runtime = O(nlogn), Space = O(1)

JavaScript

var findContentChildren = function(g, s) {
var increase = function(a,b){return a-b;};
let res = 0;
let cookie = s.length-1;
let kid = g.length-1;
s.sort(increase);
g.sort(increase);
while (cookie >= 0 && kid >= 0){
    if (g[kid] <= s[cookie]){ 
        res++;
        kid --;
        cookie--;
    }else{kid--;};
};
return res;
};

kidexp commented 2 years ago

thoughts

两个数组排序之后，按照size去满足尽量多的grady factor

code


class Solution:
    def findContentChildren(self, g: List[int], s: List[int]) -> int:
        s.sort()
        g.sort()

        i = 0
        for j, greedy_factor in enumerate(g):
            while i < len(s) and s[i] < greedy_factor:
                i += 1
            if i < len(s) and s[i] >= greedy_factor:
                i += 1
            else:
                return j
        return len(g)

complexity

m 为g的长度， n为s的长度 Time O(mlgm+nlgn + m +n) = O(mlgm+nlgn)

Space O(1)

CoreJa commented 2 years ago

思路

题目比较简单，经典贪心法，child数组和cookie数组分别排序，child>cookie那就试下一个cookie，child<=cookie那就匹配上了，匹配上了就下一个cookie和下一个孩子

代码

class Solution:
    def findContentChildren(self, g: List[int], s: List[int]) -> int:
        g.sort()
        s.sort()
        count = 0
        cookie_index = 0
        for child in g:
            while cookie_index < len(s) and child > s[cookie_index]:
                cookie_index += 1
            if not cookie_index < len(s):
                return count
            count += 1
            cookie_index += 1
        return count

复杂度

TC: O(nlogn) SC: O(1)

pophy commented 2 years ago

思路 - 贪心

所有饼干和孩子按从小到大排列
优先满足胃口小的孩子

Java Code

    public int findContentChildren(int[] g, int[] s) {
        Arrays.sort(g);
        Arrays.sort(s);
        int count = 0;
        int i = 0, j = 0;
        while (i < g.length && j < s.length) {
            if (g[i] <= s[j]) {
                count++;
                i++;
                j++;
            } else {
                j++;
            }            
        }        
        return count;
    }

时间&空间

时间 O(nlog(n)) - 排序
空间 O(1）

yingliucreates commented 2 years ago

link:

https://leetcode.com/problems/assign-cookies/

代码 Javascript

const findContentChildren = function (g, s) {
  g.sort(function (a, b) {
    return a - b;
  });
  s.sort(function (a, b) {
    return a - b;
  });
  let j = 0;

  s.forEach((element) => {
    if (element >= g[j]) {
      j++;
    }
  });
  return j;
};

ZacheryCao commented 2 years ago

Idea:

Greedy. Sort both array at first. Then for each pair of child and cookie check whether the child can be content, if so, move to next child and cookie and add ans by one. If the child cannot be content, move to next cookie.

Code:

class Solution:
    def findContentChildren(self, g: List[int], s: List[int]) -> int:
        g = sorted(g)
        s = sorted(s)
        i, j, ans = 0, 0, 0
        while i < len(g) and j < len(s):
            if g[i] <= s[j]:
                i += 1
                j += 1
                ans += 1
            else:
                j += 1
        return ans

Complexity:

Time: O(nlogn). n = max(length of children array, length of cookie array) Sapce: O(1)

zjsuper commented 2 years ago

idea: greedy, find the closest s for each g

class Solution:
    def findContentChildren(self, g: List[int], s: List[int]) -> int:
        ans = 0
        if not s:
            return 0
        g.sort()
        s.sort()
        for gg in g:
            for ss in s:
                if ss >= gg:
                    ans += 1
                    s.remove(ss)
                    break
        return ans

double pointers

class Solution:
    def findContentChildren(self, g: List[int], s: List[int]) -> int:
        ans = 0
        if not s:
            return 0
        g.sort()
        s.sort()
        l = 0
        r = 0
        while l< len(g) and r < len(s):
            if g[l]<=s[r]:
                ans += 1
                l += 1
                r += 1
            else:
                r += 1
        return ans

Time: O(nlogn). n = max(length of children array, length of cookie array) Sapce: O(1)

ai2095 commented 2 years ago

455. Assign Cookies

https://leetcode.com/problems/assign-cookies/

Topics

Greedy

思路

Greedy

代码 Python

class Solution:
    def findContentChildren(self, g: List[int], s: List[int]) -> int:
        if not s:
            return 0
        g.sort()
        s.sort()

        res = 0
        g_i, s_i = len(g) - 1, len(s) - 1
        while g_i >= 0 and s_i >= 0:
            if g[g_i] <= s[s_i]:
                res += 1
                g_i -= 1
                s_i -= 1
            else:
                g_i -= 1
        return res

复杂度分析

DP 时间复杂度： O(NlogN)
空间复杂度：O(N)

RocJeMaintiendrai commented 2 years ago

代码

class Solution {
    public int findContentChildren(int[] g, int[] s) {
        Arrays.sort(g);
        Arrays.sort(s);
        int idxG = 0;
        int idxS = 0;
        int res = 0;

        while(idxG < g.length && idxS < s.length) {
            if(g[idxG] <= s[idxS]) {
                res++;
                idxG++;
                idxS++;
            } else {
                idxS++;
            }
        }

        return res;
    }
}

复杂度分析

时间复杂度

O(nlogn)

空间复杂度

O(1)

skinnyh commented 2 years ago

Note

Sort the two lists. Then use two pointers to start from the child with smallest greed factor, try to match the need with the smallest available cookie because a lager cookie can possibly match with a child with larger greed factor.

Solution

class Solution:
    def findContentChildren(self, g: List[int], s: List[int]) -> int:
        g.sort()
        s.sort()
        j = res = 0
        for i in range(len(g)):
            while j < len(s) and g[i] > s[j]:
                j += 1
            if j >= len(s):
                break
            res += 1
            j += 1
        return res

Time complexity: O(NlogN)

Space complexity: O(1)

yachtcoder commented 2 years ago

O(nlgn), O(1)

class Solution:
    def findContentChildren(self, g: List[int], s: List[int]) -> int:
        g.sort()
        s.sort()
        gi, si = 0, 0
        ret = 0
        while gi < len(g) and si < len(s):
            gn, sn = g[gi], s[si]
            if gn <= sn:
                ret += 1
                gi += 1
                si += 1                
            else:
                si += 1
        return ret

itsjacob commented 2 years ago

Intuition

[tags] two-pointers, greedy
one cookie can only be assigned to one person

Implementation

class Solution
{
public:
  int findContentChildren(vector<int> &g, vector<int> &s)
  {
    std::sort(g.begin(), g.end());
    std::sort(s.begin(), s.end());
    int i{ 0 };
    int j{ 0 };
    int res{ 0 };
    // Notice each element in the cookie array can only be assigned to one child
    while (i < g.size() && j < s.size()) {
      if (s[j] >= g[i]) {
        res++;
        // s[j] -= g[i];
        j++;
        i++;
      } else {
        j++;
      }
    }
    return res;
  }
};

Complexity

Time complexity: O(max{NlogN, MlogM}), where N and M are the sizes of g and s
Space complexity: O(1)

Daniel-Zheng commented 2 years ago

思路

贪心。

代码(C++)

class Solution {
public:
    int findContentChildren(vector<int>& g, vector<int>& s) {
        sort(g.begin(), g.end());
        sort(s.begin(), s.end());
        int numOfChildren = g.size(), numOfCookies = s.size();
        int count = 0;
        for (int i = 0, j = 0; i < numOfChildren && j < numOfCookies; i++, j++) {
            while (j < numOfCookies && g[i] > s[j]) j++;
            if (j < numOfCookies) count++;
        }
        return count;
    }
};

复杂度分析

时间复杂度：O(NLogN)
空间复杂度：O(1)

fzzfgbw commented 2 years ago

思路

贪心

代码

class Solution {
    public int findContentChildren(int[] g, int[] s) {
        Arrays.sort(g);
        Arrays.sort(s);
        int gl = g.length;
        int sl = s.length;
        int res= 0;
        for(int i = 0,j = 0;i<gl&&j<sl;i++,j++){
            while(j<sl && s[j]<g[i]){
                j++;
            }
            if(j<sl){
                res++;
            }

        }
        return res;
    }
}

复杂度分析

时间复杂度：O(max(nlogn+mlogm))
空间复杂度：O(1)

mannnn6 commented 2 years ago

代码

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

复杂度

时间复杂度：O(MlogM+NlogN) 空间复杂度：O(logM+logN)

yan0327 commented 2 years ago

思路：关键是排序 + 双指针遍历保证蛋糕尺寸最小的给胃口最小的儿童，否则换蛋糕

func findContentChildren(g []int, s []int) int {
    sort.Ints(g)
    sort.Ints(s)
    i,j,out:=0,0,0
    for i < len(g)&&j<len(s){
        if s[j] >=g[i]{
            i++
            j++
            out++
        }else{
            j++
        }
    }
    return out
}

时间复杂度：O（nlogn）空间复杂度O（1）

chaggle commented 2 years ago

title: "Day 65 455. 分发饼干" date: 2021-11-13T08:54:19+08:00 tags: ["Leetcode", "c++", "Greed"] categories: ["91-day-algorithm"] draft: true

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.
 

提示：

1 <= g.length <= 3 * 104
0 <= s.length <= 3 * 104
1 <= g[i], s[j] <= 2^31 - 1

题目思路

1、贪心法，优先满足最近的原则，排序两个数组，优先满足胃口最小的孩子，返回满足孩子的个数即可。

class Solution {
public:
    int findContentChildren(vector<int>& g, vector<int>& s) {
        sort(g.begin(), g.end());
        sort(s.begin(), s.end());
        int n = g.size(), m = s.size();
        int count = 0;
        for (int i = 0, j = 0; i < n && j < m; i++, j++) {
            while (j < m && g[i] > s[j]) j++;
            if (j < m) count++;
        }
        return count;
    }
};

复杂度

时间复杂度：O(n)
空间复杂度：O(1)

carterrr commented 2 years ago


class 分发饼干_455 {
    public int findContentChildren(int[] g, int[] s) {
        Arrays.sort(s);
        Arrays.sort(g);
        int i=0, j=0, res=0;
        // 贪心模板  ： 不断尝试  用小的匹配大的 
        // 双指针
        //  while () { 最小的饼干能满足当前胃口的孩子 res ++  否则用大点的饼干来喂当前的孩子 }   
        while(i < s.length && j < g.length) {
            if(s[i] >= g[j]) {
                i ++;
                j ++;
                res ++;
            } else {
                i ++;
            }
        }

        return res;
    }
}

watermelonDrip commented 2 years ago

class Solution:
    def findContentChildren(self, g: List[int], s: List[int]) -> int:
        s.sort()
        g.sort()
        res = 0
        len_n = min(len(g),len(s))
        i,j = len(g)-1 ,len(s)-1
        while i >=0 and  j>=0:
            print(g[i],s[j])
            if g[i]<=s[j]:
                res+=1
                i-=1
                j-=1
            else:
                i-=1
        return res

wenlong201807 commented 2 years ago

代码块


var findContentChildren = function (g, s) {
  g = g.sort((a, b) => a - b);
  s = s.sort((a, b) => a - b);
  let result = 0;
  let index = s.length - 1;
  for (let i = g.length - 1; i >= 0; i--) {
    if (index >= 0 && s[index] >= g[i]) {
      result++;
      index--;
    }
  }
  return result;
};

时间复杂度和空间复杂度

时间复杂度 O(n)
空间复杂度 O(1)

Francis-xsc commented 2 years ago

思路

排序+双指针

代码


class Solution {
public:
    int findContentChildren(vector<int>& g, vector<int>& s) {
        sort(g.begin(),g.end());
        sort(s.begin(),s.end());
        int i=0,j=0,res=0;
        int glen=g.size(),slen=s.size();
        while(i<glen&&j<slen){
            if(s[j]>=g[i]){
                res++;
                i++;
                j++;
            }else{
                j++;
            }
        }
        return res;
    }
};

复杂度分析

时间复杂度：O(mlogm+nlogn))
空间复杂度：O(logm+logn

ghost commented 2 years ago

题目

Assign Cookies

思路

Greedy

代码

class Solution:
    def findContentChildren(self, g: List[int], s: List[int]) -> int:
        g.sort()
        s.sort()

        res = i = j = 0 

        while(i<len(g) and j<len(s)):
            if s[j] >= g[i]: 
                res+=1
                i+=1
            j+=1

        return res

复杂度

Space: O(1) Time: O(nlogn)

Taylucky commented 2 years ago

题目地址(455. 分发饼干)

https://leetcode-cn.com/problems/assign-cookies/

题目描述

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

前置知识

排序、贪心算法

思路

先对孩子的胃口、饼干尺寸从小到大排序；然后比较。

关键点

代码

语言支持：C

C Code:

int findContentChildren(int* g, int gSize, int* s, int sSize){
    int cmpfunc (const void * a, const void * b){
         return ( *(int*)a - *(int*)b );
    }
    qsort(g,gSize,sizeof(int),cmpfunc);
    qsort(s,sSize,sizeof(int),cmpfunc);

    int p1=0,p2=0;
    int cnt=0;
    while(p2<sSize&&p1<gSize){
        if(s[p2]>=g[p1]){
            p1++;
            p2++;
            cnt++;
        }else{
        if(s[p2]<g[p1]){
            p2++;
        }
        }
    }
    return cnt;
}

复杂度分析

令 n 为数组长度。

时间复杂度：O(n)
空间复杂度：O(n)

akxuan commented 2 years ago

class Solution:
    def findContentChildren(self, g: List[int], s: List[int]) -> int:
        g.sort()
        s.sort()

        res = 0 

        gi,si =0,0
        while (gi < len(g) and si < len(s)):
            if s[si] < g[gi]:
                si += 1

            else :

                gi += 1
                si += 1
                res +=1     

        return res

ychen8777 commented 2 years ago

思路

排序，为 s、g 各分配一指针，根据条件向后移

代码

class Solution {
    public int findContentChildren(int[] g, int[] s) {

        Arrays.sort(g);
        Arrays.sort(s);

        int i = 0, j = 0, res = 0;
        while (i < g.length && j < s.length) {

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

        }

        return res;
    }
}

复杂度

时间: O(mlogm + nlogn) \ 空间: O(logm + logn)

wangyifan2018 commented 2 years ago

class Solution:
    def findContentChildren(self, g: List[int], s: List[int]) -> int:
        g.sort()
        s.sort()
        m, n = len(g), len(s)
        i, j, count = 0, 0, 0
        while i < m and j < n:
            while j < n and g[i] > s[j]:
                j += 1
            if j < n:
                count += 1
            i += 1
            j += 1
        return count

joeytor commented 2 years ago

思路

先对两个数组进行排序

尽可能将小的饼干先给胃口小的孩子

如果现在这个饼干可以满足这个孩子, 那么指向两个数组的指针都 +1, 并且计数的 num 也 +1

否则说明现在都饼干无法满足现在胃口最小的孩子的胃口, 那么指向下一块饼干直到能满足现在胃口最小的孩子或者没有多余的饼干位置

最后返回 num

class Solution:
    def findContentChildren(self, g: List[int], s: List[int]) -> int:
        g.sort()
        s.sort()

        i_s, i_g = 0, 0
        num = 0

        while i_s < len(s) and i_g < len(g):
            if s[i_s] >= g[i_g]:
                num += 1
                i_s += 1
                i_g += 1
            else:
                i_s += 1

        return num

复杂度

n, m 为 g 和 s 的长度

时间复杂度: O(nlogn + mlogm) O(nlogn) 和 O(mlogm) 是对两个数组的排序复杂度, 遍历的复杂度是 O(n+m)

空间复杂度: O(1)

septasset commented 2 years ago

Day 65

代码(Python)

class Solution:
    def findContentChildren(self, g: List[int], s: List[int]) -> int:
        g.sort()
        s.sort()

        ptr = 0
        for size in s:
            if size<g[ptr]: continue
            else:
                ptr+=1
                if ptr>len(g)-1: break
        return ptr

ZJP1483469269 commented 2 years ago

思路

动态规划

代码

class Solution {
    public int findContentChildren(int[] g, int[] s) {
        Arrays.sort(g);
        Arrays.sort(s);
        int ng = g.length , ns = s.length;
        int[] dp = new int[ns+1];
        int nc = 0;
        for(int i = 1 ; i <= ns ;i++){
            dp[i] = dp[i-1];
            for(int j = nc + 1 ; j <= ng ; j++){
                if(s[i-1] >= g[j-1]){
                    dp[i] = dp[i-1] + 1;
                    break;
                }
            }
            nc = dp[i];
        }
        return dp[ns];
    }
}

复杂度分析

时间复杂度：O（ns * ng）空间复杂度：O（ns）

zszs97 commented 2 years ago

开始刷题

题目简介

【Day 61 】2021-11-09 - 416. 分割等和子集

题目思路

贪心算法

题目代码

代码块

class Solution {
public:
    int findContentChildren(vector<int>& g, vector<int>& s) {
        sort(g.begin(), g.end());
        sort(s.begin(), s.end());
        int numOfChildren = g.size(), numOfCookies = s.size();
        int count = 0;
        for (int i = 0, j = 0; i < numOfChildren && j < numOfCookies; i++, j++) {
            while (j < numOfCookies && g[i] > s[j]) {
                j++;
            }
            if (j < numOfCookies) {
                count++;
            }
        }
        return count;
    }
};

复杂度

时间复杂度 O(mlogm+nlogn)
空间复杂度 O(logm+logn)

bingyingchu commented 2 years ago


class Solution:
    def findContentChildren(self, g: List[int], s: List[int]) -> int:
        g.sort()
        s.sort()

        result = 0
        i = 0
        j = 0

        while i < len(g) and j < len(s):
            if g[i] <= s[j]:
                result += 1
                i += 1
                j += 1
            else:
                j += 1
        return result

Time: O(nlogn) - sorting 
Space: O(1)

kennyxcao commented 2 years ago

455. Assign Cookies

Intuition

Greedy

Code

/**
 * @param {number[]} g
 * @param {number[]} s
 * @return {number}
 */
const findContentChildren = function(g, s) {
  g.sort((a, b) => a - b);
  s.sort((a, b) => a - b);
  let count = 0;
  let i = 0;
  for (let j = 0; j < s.length; j++) {
    if (i === g.length) break;
    if (s[j] >= g[i]) {
      count += 1;
      i += 1;
    }
  }
  return count;
};

Complexity Analysis

Time: O(nlogn + mlogm),
Space: O(1)

user1689 commented 2 years ago

题目

https://leetcode-cn.com/problems/assign-cookies/

思路

Greedy

python3

class Solution:
    def findContentChildren(self, g: List[int], s: List[int]) -> int:
        g.sort()
        s.sort()
        i = 0 
        j = 0
        count = 0
        while(i < len(g) and j < len(s)):
            # 如果此时孩子的食量比饼干分量大,那么在不超出范围的情况下，往后遍历
            while(j < len(s) and s[j] < g[i]):
                j += 1
            # 如果在有限饼干范围内，找到了满足孩子胃口的那一块，就继续往后遍历，并且计数值+1
            if (j < len(s)):
                count += 1
            i += 1
            j += 1
        return count

复杂度分析

time nlogn + mlogm
space 1

思路

贪心的基本思想，尽量用小饼干去喂饱小胃口的孩子，这样就能喂饱最多的孩子。所以先排序，再比较

代码

public int findContentChildren(int[] g, int[] s) {
  Arrays.sort(g);
  Arrays.sort(s);
  int idx = 0;
  for (int i=0; i<s.length && idx<g.length; i++) {
    if (s[i] >= g[idx]) {
      idx++;
    }
  }

  return idx;
    }
}

TC: O(NLogN) 排序 SC: O(LogN) 排序

leetcode-pp / 91alg-5-daily-check

【Day 65 】2021-11-13 - 455. 分发饼干 #84

455. 分发饼干

入选理由

题目地址

前置知识

题目描述

思路:

方法: 贪心 + 双指针

代码:

复杂度分析:

Idea:

Complexity:

解题思路

代码

【Day 65】455. 分发饼干

思路

代码

复杂度

思路

代码

代码

思路

代码

思路

代码

Time complexity

思路

关键点

代码

Problem

Notes

Solution

Complexity

Idea

JavaScript

thoughts

code

complexity

思路

代码

复杂度

思路 - 贪心

Java Code

时间&空间

link:

代码 Javascript

Idea:

Code:

Complexity:

idea: greedy, find the closest s for each g

455. Assign Cookies

Topics

思路

代码 Python

复杂度分析

代码

复杂度分析

时间复杂度

空间复杂度

Note

Solution

Intuition

Implementation

Complexity

思路

代码(C++)

复杂度分析

思路

代码

复杂度分析

代码

复杂度

455. 分发饼干

题目

题目思路

复杂度

代码块

时间复杂度和空间复杂度

思路

思路：贪心