55. 跳跃游戏
难度中等
给定一个非负整数数组，你最初位于数组的第一个位置。
数组中的每个元素代表你在该位置可以跳跃的最大长度。
判断你是否能够到达最后一个位置。
示例 1:
输入: [2,3,1,1,4] 输出: true 解释: 我们可以先跳 1 步，从位置 0 到达 位置 1, 然后再从位置 1 跳 3 步到达最后一个位置。
示例 2:
输入: [3,2,1,0,4] 输出: false 解释: 无论怎样，你总会到达索引为 3 的位置。但该位置的最大跳跃长度是 0 ， 所以你永远不可能到达最后一个位置。
1 class Solution: 2 def canJump(self, nums: List[int]) -> bool: 3 if not nums: 4 return True 5 6 nums_len = len(nums) 7 #good_positions[index] = True 代表从index能到达最后一个位置 8 good_positions = [False for _ in range(nums_len)] 9 good_positions[nums_len-1] = True 10 min_good_position = nums_len - 1 11 12 for index in range(nums_len-2, -1, -1): 13 if nums[index] >= (min_good_position-index): 14 min_good_position = index 15 good_positions[index] = True 16 17 return good_positions[0]
122. 买卖股票的最佳时机 II
难度简单
给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。
设计一个算法来计算你所能获取的最大利润。你可以尽可能地完成更多的交易（多次买卖一支股票）。
注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。
示例 1:
输入: [7,1,5,3,6,4] 输出: 7 解释: 在第 2 天（股票价格 = 1）的时候买入，在第 3 天（股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。 随后，在第 4 天（股票价格 = 3）的时候买入，在第 5 天（股票价格 = 6）的时候卖出, 这笔交易所能获得利润 = 6-3 = 3 。
示例 2:
输入: [1,2,3,4,5] 输出: 4 解释: 在第 1 天（股票价格 = 1）的时候买入，在第 5 天 （股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。 注意你不能在第 1 天和第 2 天接连购买股票，之后再将它们卖出。 因为这样属于同时参与了多笔交易，你必须在再次购买前出售掉之前的股票。
示例 3:
输入: [7,6,4,3,1] 输出: 0 解释: 在这种情况下, 没有交易完成, 所以最大利润为 0。
1 def maxProfit(self, prices: List[int]) -> int: 2 prices_len = len(prices) 3 max_profit = 0 4 5 index = 0 6 7 while index < prices_len: 8 while index < prices_len-1 and prices[index] > prices[index+1]: 9 index += 1 10 valley = prices[index] 11 12 while index < prices_len-1 and prices[index] < prices[index+1]: 13 index +=1 14 peak = prices[index] 15 16 max_profit += (peak - valley) 17 18 index += 1 19 20 return max_profit
1 def maxProfit(self, prices: List[int]) -> int: 2 3 prices_len = len(prices) 4 if 1 >= prices_len: 5 return 0 6 max_profit = 0 7 8 for index in range(1, len(prices)): 9 if prices[index] > prices[index-1]: 10 max_profit += (prices[index] - prices[index-1]) 11 12 return max_profit
945. 使数组唯一的最小增量
难度中等
给定整数数组 A，每次 move 操作将会选择任意 A[i]，并将其递增 1。
返回使 A 中的每个值都是唯一的最少操作次数。
示例 1:
输入：[1,2,2] 输出：1 解释：经过一次 move 操作，数组将变为 [1, 2, 3]。
示例 2:
输入：[3,2,1,2,1,7] 输出：6 解释：经过 6 次 move 操作，数组将变为 [3, 4, 1, 2, 5, 7]。 可以看出 5 次或 5 次以下的 move 操作是不能让数组的每个值唯一的。
提示：
0 <= A.length <= 400000 <= A[i] < 40000
题解：
贪心算法在于每个子问题的局部最优解会指向全局最优解。
显然在对数组排序之后，可以通过保证数组的最后一个元素，经过+1操作后比前面所有元素大即可,此时子问题的最优解会收敛于全局最优解。
1 class Solution: 2 def minIncrementForUnique(self, A: List[int]) -> int: 3 A.sort() 4 count = 0 5 for i in range(1, len(A)): 6 if A[i] <= A[i - 1]: 7 count += A[i - 1] - A[i] + 1 8 A[i] = A[i - 1] + 1 9 return count