贪心算法

55. 跳跃游戏

难度中等510

给定一个非负整数数组，你最初位于数组的第一个位置。

数组中的每个元素代表你在该位置可以跳跃的最大长度。

判断你是否能够到达最后一个位置。

示例 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

难度简单633

给定一个数组，它的第 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. 使数组唯一的最小增量

难度中等121收藏分享切换为英文关注反馈

给定整数数组 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 操作是不能让数组的每个值唯一的。

提示：

1. 0 <= A.length <= 40000
2. 0 <= 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

 

来源：https://www.cnblogs.com/dede-0119/p/12544136.html