leetcode-01-贪心算法

455

#算法/贪心
#算法/python-leetcode/455

力扣

class Solution:
    def findContentChildren(self, g: list, s: list) -> int:
        # g 胃口
        # s 饼干
        s.sort()
        g.sort()
        cnt = 0
        g_i, s_i = 0, 0
        g_length, s_length = len(g), len(s)
        while g_i < g_length and s_i < s_length:
            if g[g_i] <= s[s_i]:
                cnt += 1
                g_i += 1
                s_i += 1
            else:
                s_i += 1
        return cnt

题解

• 首先满足饥饿感最小的孩子

135

#算法/贪心
#算法/leetcode/135

力扣

# %%
"""
135. 分发糖果
n 个孩子站成一排。给你一个整数数组 ratings 表示每个孩子的评分。

你需要按照以下要求，给这些孩子分发糖果：

每个孩子至少分配到 1 个糖果。
相邻两个孩子评分更高的孩子会获得更多的糖果。
请你给每个孩子分发糖果，计算并返回需要准备的 最少糖果数目 。

示例 1：

输入：ratings = [1,0,2]
输出：5
解释：你可以分别给第一个、第二个、第三个孩子分发 2、1、2 颗糖果。
示例 2：

输入：ratings = [1,2,2]
输出：4
解释：你可以分别给第一个、第二个、第三个孩子分发 1、2、1 颗糖果。
     第三个孩子只得到 1 颗糖果，这满足题面中的两个条件。



n == ratings.length
1 <= n <= 2 * 10^4
0 <= ratings[i] <= 2 * 10^4

"""

# %%

class Solution:
    def candy(self, ratings: list) -> int:
        n = len(ratings)
        candies = [1] * n

        for i in range(1, n):
            if ratings[i] > ratings[i - 1]:
                candies[i] = candies[i-1]+1
        for i in range(n - 2, -1, -1):
            if ratings[i] > ratings[i + 1] and candies[i] <= candies[i + 1]:
                candies[i] = candies[i+1]+1

        return sum(candies)
s = Solution()
ratings = [1, 2, 2]
print(s.candy(ratings))

题解

• 循环两遍 ，每次只考虑左边或者右边

435

#算法/leetcode/435
#算法/贪心

"""
435. 无重叠区间
给定一个区间的集合 intervals ，其中 intervals[i] = [starti, endi] 。返回 需要移除区间的最小数量，使剩余区间互不重叠 。



示例 1:

输入: intervals = [[1,2],[2,3],[3,4],[1,3]]
输出: 1
解释: 移除 [1,3] 后，剩下的区间没有重叠。
示例 2:

输入: intervals = [ [1,2], [1,2], [1,2] ]
输出: 2
解释: 你需要移除两个 [1,2] 来使剩下的区间没有重叠。
示例 3:

输入: intervals = [ [1,2], [2,3] ]
输出: 0
解释: 你不需要移除任何区间，因为它们已经是无重叠的了。


提示:

1 <= intervals.length <= 10^5
intervals[i].length == 2
-5 * 10^4 <= start_i < end_i <= 5 * 10^4
"""

# %%
class Solution:
    def eraseOverlapIntervals(self, intervals) -> int:
        #  需要移除区间的最小数量，使剩余区间互不重叠 。
        # 降序x1后，若x1相同，删除步长更大的
        intervals.sort(key=lambda x: x[1])
        cnt = 0
        pre_end = intervals[0][1]
        for idx, interval in enumerate(intervals):
            if idx == 0:
                continue
            else:
                cur_start, cur_end = interval
                if pre_end > cur_start:
                    cnt += 1
                else:
                    pre_end = interval[1]
        return cnt


intervals = [[1,2],[2,3],[3,4],[1,3]]
s = Solution()
print(s.eraseOverlapIntervals(intervals))

题解

    - 删除步长更大的
    - start肯定小于end， 使用end进行排序即可