技術標籤：leetcode

暴力

class Solution:
    def findContentChildren(self, g: List[int], s: List[int]) -> int:
        ans = 0        
        cg = Counter(sorted(g))
        cs = Counter(sorted(s))

        # 匹配剩下的元素
        for gk in cg.keys():
            for ck in cs.keys():
                if ck >=
 
 gk and cs[ck] != 0:
                    t = min(cs[ck],cg[gk]) 
                    cg[gk] -= t
                    cs[ck] -= t
                    ans += t
                    if cg[gk] == 0:
                        break
        
        return ans

每個g[i]的元素消除掉s中大於等於g[i]的元素，並且是從小到大消除，所以構造dict之前要先排序

如果不是按順序消除，那麼

g =[1,2,3] s=[3,1,1]
g[0] = 1消除了3，然後剩下的s無法滿足任何一個元素，答案為1
但實際上正確答案是2，1和3互相消除一個元素

時間複雜度 O ( m ∗ n ) O(m*n) O(m∗n)
空間複雜度 O ( m + n ) O(m+n) O(m+n)，構造了字典

優化後的暴力

還是要sorted
如果直接在兩個陣列中模擬的話，時間複雜度還是會到 O ( m ∗ n ) O(m*n) O(m∗n)

class Solution:
    def findContentChildren(self, g: List[int], s: List[
 
int]) -> int:
        g = sorted(g)
        s = sorted(s)
        count = 0
        for i in s:
            if i >= g[count]:
                count += 1
            if count == len(g):
                break
                
        return count

一趟迴圈
時間複雜度 O ( n l o g n ) O(nlogn) O(nlogn)

官方題解寫得不如上面的簡潔