hot100 -- 14.贪心算法

1.买卖股票的最佳时机

方法：

def MaxProfit(prices):
    max_pro, min_num = 0, float('inf')
    for num in prices:
        if num < min_num:
            min_num = num
        max_pro = max(max_pro, num - min_num)
    return max_pro

2.跳跃游戏

问题：

给你一个非负整数数组 nums ，你最初位于数组的 第一个下标 。数组中的每个元素代表你在该位置可以跳跃的最大长度。

判断你是否能够到达最后一个下标，如果可以，返回 true ；否则，返回 false 。

方法1：动态规划（不推荐）

# 方法1：动态规划：记录每一个位置能否到达
def MaxProfit(nums):
    dp = [False] * len(nums)
    # 考虑首元素为0的情况
    if len(nums)==1 and nums[0]==0:
        return True
    elif nums[0]==0:
        return False

    dp[0] = True
    for i in range(len(nums)):
        # 如果能到达，开始跳跃
        if dp[i]:
            for j in range(1, nums[i]+1):
                if i+j < len(nums):
                    dp[i+j] = True
                else:
                    return True
        # 不能到达，直接返回
        else:
            return False
    return dp[-1]

方法2：贪心算法：只关心最终能否到达（推荐）

# 贪心算法（只记最远点）
# 如果当前点到不了，直接False
def canJump(nums):
    max_index = 0
    for i in range(len(nums)):
        if i > max_index:                       # 到不了该点（直接返回False）
            return False
        max_index = max(max_index, i + nums[i]) # 只记最远点
    return True

3.跳跃游戏 II

问题：

给定一个长度为 n 的 0 索引整数数组 nums。初始位置为 nums[0]。

每个元素 nums[i] 表示从索引 i 向后跳转的最大长度。换句话说，如果你在 nums[i] 处，你可以跳转到任意 nums[i + j] 处:

• 0 <= j <= nums[i] 
• i + j < n

返回到达 nums[n - 1] 的最小跳跃次数。生成的测试用例可以到达 nums[n - 1]。

方法：贪心 -- 最远覆盖范围

def jump(nums):
    jumps, end, next_end = 0, 0, 0
    for i in range(len(nums)-1):                    # 最后一个位置已经到达终点
        next_end = max(next_end, i + nums[i])       # 下一步的最远边界
        if i == end:                                # 到达边界，跳一步
            jumps += 1
            end = next_end                          # 更新最远边界
    return jumps

4.划分字母区间

问题：

给你一个字符串 s 。我们要把这个字符串划分为尽可能多的片段，同一字母最多出现在一个片段中。例如，字符串 "ababcc" 能够被分为 ["abab", "cc"]，但类似 ["aba", "bcc"] 或 ["ab", "ab", "cc"] 的划分是非法的。

注意，划分结果需要满足：将所有划分结果按顺序连接，得到的字符串仍然是 s 。

返回一个表示每个字符串片段的长度的列表。

方法：最远覆盖法（关门发车法）

# 最远覆盖法（关门发车法）
# 以最远元素为边界，到达边界了就“发车”
# 继续下一节“车厢”，以此类推
def partitionLabels(s):
    last_index, res = {}, []
    start, end = 0, 0
    # 记录每个字符最终位置
    for i, char in enumerate(s):
        last_index[char] = i
    # 划分
    for i in range(len(s)):
        end = max(end, last_index[s[i]])    # 更新区间右边界（以最远元素为边界）
        if i == end:                        # 到达边界
            res.append(end - start + 1)     # 记录区间长度
            start = end + 1                 # 更新区间左边界
    return res