直接上文章链接。
贪心理论基础
class Solution:
def findContentChildren(self, g: List[int], s: List[int]) -> int:
g.sort()
s.sort()
gmin = g[0]
n = len(s)
m = len(g)
i = 0
while i < n :
if s[i]>=gmin :
break
i += 1
s = s[i:]
n = len(s)
count = 0
i = j = 0
while i < n and j < m :
if s[i]>=g[j]:
i += 1
j += 1
count += 1
else :
i += 1
return count
class Solution:
def findContentChildren(self, g: List[int], s: List[int]) -> int:
g.sort()
s.sort()
gmin = g[0]
n = len(s)
m = len(g)
count = 0
i = j = 0
while i < n and j < m :
if s[i]>=g[j]:
i += 1
j += 1
count += 1
else :
i += 1
return count
基本和我也差不多一个思路。
贪心 大饼干优先
class Solution:
def findContentChildren(self, g, s):
g.sort() # 将孩子的贪心因子排序
s.sort() # 将饼干的尺寸排序
index = len(s) - 1 # 饼干数组的下标,从最后一个饼干开始
result = 0 # 满足孩子的数量
for i in range(len(g)-1, -1, -1): # 遍历胃口,从最后一个孩子开始
if index >= 0 and s[index] >= g[i]: # 遍历饼干
result += 1
index -= 1
return result
贪心 小饼干优先
class Solution:
def findContentChildren(self, g, s):
g.sort() # 将孩子的贪心因子排序
s.sort() # 将饼干的尺寸排序
index = 0
for i in range(len(s)): # 遍历饼干
if index < len(g) and g[index] <= s[i]: # 如果当前孩子的贪心因子小于等于当前饼干尺寸
index += 1 # 满足一个孩子,指向下一个孩子
return index # 返回满足的孩子数目
感觉还是小饼干优先,更适合我的逻辑。
class Solution:
def findContentChildren(self, g, s):
g.sort() # 将孩子的贪心因子排序
s.sort() # 将饼干的尺寸排序
index = 0
for i in range(len(s)): # 遍历饼干
if index < len(g) and g[index] <= s[i]: # 如果当前孩子的贪心因子小于等于当前饼干尺寸
index += 1 # 满足一个孩子,指向下一个孩子
return index # 返回满足的孩子数目
不会做,想不到怎么使用贪心算法,能想到使用动态规划能做,但是目前按照代码随想录的进度,还没学到动态规划,也不会写。
删除单调坡度上的元素,保留所有峰值。
没有必要真的去做删除元素的操作,因为删除操作本身是O(n),而且题目要求,本身也只是返回一个长度值。
定义两个变量,一个prediff,一个currentdiff,这样判断条件就清晰了!
此题细节很多,一遍都注意到很不容易,可以多去看解析。
摆动序列
动态规划,目前还没学习,代码也没太看懂。
贪心(版本一)
class Solution:
def wiggleMaxLength(self, nums):
if len(nums) <= 1:
return len(nums) # 如果数组长度为0或1,则返回数组长度
curDiff = 0 # 当前一对元素的差值
preDiff = 0 # 前一对元素的差值
result = 1 # 记录峰值的个数,初始为1(默认最右边的元素被视为峰值)
for i in range(len(nums) - 1):
curDiff = nums[i + 1] - nums[i] # 计算下一个元素与当前元素的差值
# 如果遇到一个峰值
if (preDiff <= 0 and curDiff > 0) or (preDiff >= 0 and curDiff < 0):
result += 1 # 峰值个数加1
preDiff = curDiff # 注意这里,只在摆动变化的时候更新preDiff
return result # 返回最长摆动子序列的长度
贪心(版本二)
class Solution:
def wiggleMaxLength(self, nums: List[int]) -> int:
if len(nums) <= 1:
return len(nums) # 如果数组长度为0或1,则返回数组长度
preDiff,curDiff ,result = 0,0,1 #题目里nums长度大于等于1,当长度为1时,其实到不了for循环里去,所以不用考虑nums长度
for i in range(len(nums) - 1):
curDiff = nums[i + 1] - nums[i]
if curDiff * preDiff <= 0 and curDiff !=0: #差值为0时,不算摆动
result += 1
preDiff = curDiff #如果当前差值和上一个差值为一正一负时,才需要用当前差值替代上一个差值
return result
动态规划(版本一)
class Solution:
def wiggleMaxLength(self, nums: List[int]) -> int:
# 0 i 作为波峰的最大长度
# 1 i 作为波谷的最大长度
# dp是一个列表,列表中每个元素是长度为 2 的列表
dp = []
for i in range(len(nums)):
# 初始为[1, 1]
dp.append([1, 1])
for j in range(i):
# nums[i] 为波谷
if nums[j] > nums[i]:
dp[i][1] = max(dp[i][1], dp[j][0] + 1)
# nums[i] 为波峰
if nums[j] < nums[i]:
dp[i][0] = max(dp[i][0], dp[j][1] + 1)
return max(dp[-1][0], dp[-1][1])
动态规划(版本二)
class Solution:
def wiggleMaxLength(self, nums):
dp = [[0, 0] for _ in range(len(nums))] # 创建二维dp数组,用于记录摆动序列的最大长度
dp[0][0] = dp[0][1] = 1 # 初始条件,序列中的第一个元素默认为峰值,最小长度为1
for i in range(1, len(nums)):
dp[i][0] = dp[i][1] = 1 # 初始化当前位置的dp值为1
for j in range(i):
if nums[j] > nums[i]:
dp[i][1] = max(dp[i][1], dp[j][0] + 1) # 如果前一个数比当前数大,可以形成一个上升峰值,更新dp[i][1]
for j in range(i):
if nums[j] < nums[i]:
dp[i][0] = max(dp[i][0], dp[j][1] + 1) # 如果前一个数比当前数小,可以形成一个下降峰值,更新dp[i][0]
return max(dp[-1][0], dp[-1][1]) # 返回最大的摆动序列长度
动态规划(版本三)优化
class Solution:
def wiggleMaxLength(self, nums):
if len(nums) <= 1:
return len(nums) # 如果数组长度为0或1,则返回数组长度
up = down = 1 # 记录上升和下降摆动序列的最大长度
for i in range(1, len(nums)):
if nums[i] > nums[i-1]:
up = down + 1 # 如果当前数比前一个数大,则可以形成一个上升峰值
elif nums[i] < nums[i-1]:
down = up + 1 # 如果当前数比前一个数小,则可以形成一个下降峰值
return max(up, down) # 返回上升和下降摆动序列的最大长度
挺难的一道题,要好好理解。
class Solution:
def wiggleMaxLength(self, nums: List[int]) -> int:
if len(nums)<=1:
return len(nums)
curDiff = 0
preDiff = 0
result = 1
for i in range(len(nums)-1):
curDiff = nums[i+1]-nums[i]
if (preDiff<=0 and curDiff>0) or (preDiff>=0 and curDiff<0) :
result += 1
preDiff = curDiff
return result
最朴素,逻辑细致但重复版
class Solution:
def maxSubArray(self, nums: List[int]) -> int:
result = nums[0]
maxsum = nums[0]
res = nums[0]
n = len(nums)
for i in range(1,n):
if nums[i] > 0 :
if maxsum <= 0 :
result = nums[i]
maxsum = nums[i]
else :
maxsum += nums[i]
result = maxsum
else :
if maxsum <= 0:
result = nums[i]
maxsum = nums[i]
else :
maxsum += nums[i]
result = maxsum
res = max(res,result)
return res
看了重复逻辑后改进版
class Solution:
def maxSubArray(self, nums: List[int]) -> int:
result = nums[0]
maxsum = nums[0]
n = len(nums)
for i in range(1,n):
if maxsum <= 0 :
maxsum = nums[i]
else :
maxsum += nums[i]
result = max(maxsum,result)
return result
思路和我精简后的代码差不多,同样先不看动态规划的代码。
暴力法
class Solution:
def maxSubArray(self, nums):
result = float('-inf') # 初始化结果为负无穷大
count = 0
for i in range(len(nums)): # 设置起始位置
count = 0
for j in range(i, len(nums)): # 从起始位置i开始遍历寻找最大值
count += nums[j]
result = max(count, result) # 更新最大值
return result
贪心法
好好理解一下,为什么count<=0时,令count=0,因为当目前count<=0时,选择下一个元素作为我们的起点。
这个想法和我自己的想法,差一个身位。但在循环中,是等价的。
class Solution:
def maxSubArray(self, nums):
result = float('-inf') # 初始化结果为负无穷大
count = 0
for i in range(len(nums)):
count += nums[i]
if count > result: # 取区间累计的最大值(相当于不断确定最大子序终止位置)
result = count
if count <= 0: # 相当于重置最大子序起始位置,因为遇到负数一定是拉低总和
count = 0
return result
动态规划C++
class Solution {
public:
int maxSubArray(vector<int>& nums) {
if (nums.size() == 0) return 0;
vector<int> dp(nums.size(), 0); // dp[i]表示包括i之前的最大连续子序列和
dp[0] = nums[0];
int result = dp[0];
for (int i = 1; i < nums.size(); i++) {
dp[i] = max(dp[i - 1] + nums[i], nums[i]); // 状态转移公式
if (dp[i] > result) result = dp[i]; // result 保存dp[i]的最大值
}
return result;
}
};
感觉还是自己的贪心逻辑好理解一点。
class Solution:
def maxSubArray(self, nums: List[int]) -> int:
result = nums[0]
maxsum = nums[0]
n = len(nums)
for i in range(1,n):
if maxsum <= 0 :
maxsum = nums[i]
else :
maxsum += nums[i]
result = max(maxsum,result)
return result
直接上链接。
贪心系列1总结
小贪一手,贪心算法纯纯直觉,觉得作差相加就可以,稍微想了一下也没有反例。
class Solution:
def maxProfit(self, prices: List[int]) -> int:
res = 0
diff = 0
for i in range(1,len(prices)):
diff = prices[i]-prices[i-1]
if diff > 0 :
res += diff
return res
只有一只股票。
想明白利润是可以分解的!不愧是代码随想录!
从图中可以发现,其实我们需要收集每天的正利润就可以,收集正利润的区间,就是股票买卖的区间,而我们只需要关注最终利润,不需要记录区间。那么只收集正利润就是贪心所贪的地方!局部最优:收集每天的正利润,全局最优:求得最大利润。
同样有两种方法,动态规划方法还没看。
贪心
class Solution:
def maxProfit(self, prices: List[int]) -> int:
result = 0
for i in range(1, len(prices)):
result += max(prices[i] - prices[i - 1], 0)
return result
动态规划
class Solution:
def maxProfit(self, prices: List[int]) -> int:
length = len(prices)
dp = [[0] * 2 for _ in range(length)]
dp[0][0] = -prices[0]
dp[0][1] = 0
for i in range(1, length):
dp[i][0] = max(dp[i-1][0], dp[i-1][1] - prices[i]) #注意这里是和121. 买卖股票的最佳时机唯一不同的地方
dp[i][1] = max(dp[i-1][1], dp[i-1][0] + prices[i])
return dp[-1][1]
过,本题的要点在于想到,利润可以拆分为每天。
class Solution:
def canJump(self, nums: List[int]) -> bool:
n = len(nums)
count = 0
dis = 1
for i in range(n-2,-1,-1):
count += nums[i]
if count < dis :
return False
dis += 1
return True
本题重点在于理清逻辑,在想到从覆盖范围考虑后,怎样编写代码逻辑也是要小心的。
class Solution:
def canJump(self, nums: List[int]) -> bool:
index = 0
for i in range(len(nums)):
if index >= i :
index = max(index,i+nums[i])
else :
return False
if index >= len(nums)-1 :
return True
class Solution:
def canJump(self, nums: List[int]) -> bool:
cover = 0
if len(nums) == 1: return True
i = 0
# python不支持动态修改for循环中变量,使用while循环代替
while i <= cover:
cover = max(i + nums[i], cover)
if cover >= len(nums) - 1: return True
i += 1
return False
## for循环
class Solution:
def canJump(self, nums: List[int]) -> bool:
cover = 0
if len(nums) == 1: return True
for i in range(len(nums)):
if i <= cover:
cover = max(i + nums[i], cover)
if cover >= len(nums) - 1: return True
return False
class Solution:
def canJump(self, nums: List[int]) -> bool:
cover = 0
if len(nums)==1:
return True
i = 0
while i <= cover :
cover = max(cover,i+nums[i])
if cover>=len(nums)-1:
return True
i += 1
return False
没思路。
用最小的步数,去尽可能地增加我们的覆盖范围。
了解逻辑后,自己去编写了一下代码,没写对。
此题的代码逻辑也不好写。
贪心(版本一)
class Solution:
def jump(self, nums):
if len(nums) == 1:
return 0
cur_distance = 0 # 当前覆盖最远距离下标
ans = 0 # 记录走的最大步数
next_distance = 0 # 下一步覆盖最远距离下标
for i in range(len(nums)):
next_distance = max(nums[i] + i, next_distance) # 更新下一步覆盖最远距离下标
if i == cur_distance: # 遇到当前覆盖最远距离下标
ans += 1 # 需要走下一步
cur_distance = next_distance # 更新当前覆盖最远距离下标(相当于加油了)
if next_distance >= len(nums) - 1: # 当前覆盖最远距离达到数组末尾,不用再做ans++操作,直接结束
break
return ans
贪心(版本二)
class Solution:
def jump(self, nums):
cur_distance = 0 # 当前覆盖的最远距离下标
ans = 0 # 记录走的最大步数
next_distance = 0 # 下一步覆盖的最远距离下标
for i in range(len(nums) - 1): # 注意这里是小于len(nums) - 1,这是关键所在
next_distance = max(nums[i] + i, next_distance) # 更新下一步覆盖的最远距离下标
if i == cur_distance: # 遇到当前覆盖的最远距离下标
cur_distance = next_distance # 更新当前覆盖的最远距离下标
ans += 1
return ans
贪心(版本三) 类似‘55-跳跃游戏’写法
class Solution:
def jump(self, nums) -> int:
if len(nums)==1: # 如果数组只有一个元素,不需要跳跃,步数为0
return 0
i = 0 # 当前位置
count = 0 # 步数计数器
cover = 0 # 当前能够覆盖的最远距离
while i <= cover: # 当前位置小于等于当前能够覆盖的最远距离时循环
for i in range(i, cover+1): # 遍历从当前位置到当前能够覆盖的最远距离之间的所有位置
cover = max(nums[i]+i, cover) # 更新当前能够覆盖的最远距离
if cover >= len(nums)-1: # 如果当前能够覆盖的最远距离达到或超过数组的最后一个位置,直接返回步数+1
return count+1
count += 1 # 每一轮遍历结束后,步数+1
动态规划
class Solution:
def jump(self, nums: List[int]) -> int:
result = [10**4+1] * len(nums) # 初始化结果数组,初始值为一个较大的数
result[0] = 0 # 起始位置的步数为0
for i in range(len(nums)): # 遍历数组
for j in range(nums[i] + 1): # 在当前位置能够跳跃的范围内遍历
if i + j < len(nums): # 确保下一跳的位置不超过数组范围
result[i + j] = min(result[i + j], result[i] + 1) # 更新到达下一跳位置的最小步数
return result[-1] # 返回到达最后一个位置的最小步数
注意注意,此题的编写细节与上一题存在不同之处,是有一个,走到当前的最大长度后,再更新下一index。
本题的代码,要学习!
class Solution:
def jump(self, nums: List[int]) -> int:
if len(nums)==1 :
return 0
cur_distance = 0
ans = 0
next_distance = 0
for i in range(len(nums)):
next_distance = max(nums[i]+i,next_distance)
if i == cur_distance :
ans += 1
cur_distance = next_distance
if next_distance >= len(nums)-1 :
break
return ans
需要注意的细节还是比较多的,Debug了几次才通过。
class Solution:
def largestSumAfterKNegations(self, nums: List[int], k: int) -> int:
nums.sort()
n = len(nums)
i = 0
sumsum = sum(nums)
if nums[0] == 0 :
return sumsum
if nums[0] > 0 :
if k % 2 == 0:
return sumsum
else :
return sumsum-2*nums[0]
while i < n and nums[i] < 0 and k > 0 :
nums[i] = -nums[i]
i += 1
k -= 1
sumsum = sum(nums)
if k == 0 :
return sumsum
else :
if i < n :
temp = min(nums[i],nums[i-1])
if k % 2 == 0 :
return sumsum
else :
return sumsum - 2*temp
else :
temp = nums[i-1]
if k % 2 == 0 :
return sumsum
else :
return sumsum - 2*temp
一定要注意平时用贪心的题目去训练贪心的感觉,而不是靠感觉写出来就完事了。
class Solution:
def largestSumAfterKNegations(self, A: List[int], K: int) -> int:
A.sort(key=lambda x: abs(x), reverse=True) # 第一步:按照绝对值降序排序数组A
for i in range(len(A)): # 第二步:执行K次取反操作
if A[i] < 0 and K > 0:
A[i] *= -1
K -= 1
if K % 2 == 1: # 第三步:如果K还有剩余次数,将绝对值最小的元素取反
A[-1] *= -1
result = sum(A) # 第四步:计算数组A的元素和
return result
class Solution:
def largestSumAfterKNegations(self, nums: List[int], k: int) -> int:
# 第一步,按照绝对值降序排列数组
nums.sort(key=lambda x:abs(x),reverse=True)
for i in range(len(nums)):
if nums[i] < 0 and k > 0 :
nums[i] = -nums[i]
k-=1
if k % 2 == 1:
nums[-1] = -nums[i]
result = sum(nums)
return result
直接上链接。本周最值得注意的就是跳跃游戏,用拘泥于每次究竟跳几步,而是看覆盖范围,覆盖范围内一定是可以跳过来的,不用管是怎么跳的。
贪心系列2总结
超出时间限制,错误输入是一个巨长的全零序列。学习一下代码随想录是怎么解这道题的。
没想到我写的这种写法是暴力法。
class Solution:
def canCompleteCircuit(self, gas: List[int], cost: List[int]) -> int:
n = len(cost)
if sum(gas) < sum(cost):
return -1
for i in range(n):
if gas[i] < cost[i]:
continue
else :
result = 0
sumgas = 0
sumcost = 0
for j in range(i,n+i):
if j < n :
sumgas += gas[j]
sumcost += cost[j]
else :
sumgas += gas[j-n]
sumcost += cost[j-n]
if sumgas < sumcost :
result = -1
break
if result == 0 :
return i
return -1
想不到怎么使用贪心。
这道题的贪心也太巧妙了,我想不到!而且感觉贪心的不是那么直观。
暂时不去理解,贪心的方法一,更不直观了,先学习方法二。
暴力法,哈哈,卡哥的暴力法也超出时间限制
class Solution:
def canCompleteCircuit(self, gas: List[int], cost: List[int]) -> int:
for i in range(len(cost)):
rest = gas[i] - cost[i] # 记录剩余油量
index = (i + 1) % len(cost) # 下一个加油站的索引
while rest > 0 and index != i: # 模拟以i为起点行驶一圈(如果有rest==0,那么答案就不唯一了)
rest += gas[index] - cost[index] # 更新剩余油量
index = (index + 1) % len(cost) # 更新下一个加油站的索引
if rest >= 0 and index == i: # 如果以i为起点跑一圈,剩余油量>=0,并且回到起始位置
return i # 返回起始位置i
return -1 # 所有起始位置都无法环绕一圈,返回-1
贪心(版本二)
class Solution:
def canCompleteCircuit(self, gas: List[int], cost: List[int]) -> int:
curSum = 0 # 当前累计的剩余油量
totalSum = 0 # 总剩余油量
start = 0 # 起始位置
for i in range(len(gas)):
curSum += gas[i] - cost[i]
totalSum += gas[i] - cost[i]
if curSum < 0: # 当前累计剩余油量curSum小于0
start = i + 1 # 起始位置更新为i+1
curSum = 0 # curSum重新从0开始累计
if totalSum < 0:
return -1 # 总剩余油量totalSum小于0,说明无法环绕一圈
return start
学习这种写法
class Solution:
def canCompleteCircuit(self, gas: List[int], cost: List[int]) -> int:
cursum = 0
totalsum = 0
index = 0
for i in range(len(gas)):
cursum += gas[i] - cost[i]
totalsum += gas[i] - cost[i]
if cursum < 0 :
index = i+1
cursum = 0
if totalsum < 0 :
return -1
return index
没有贪心的思路,也没有其他的思路。
不能两边同时进行比较,会顾此失彼。
两边分别遍历,然后取最值
class Solution:
def candy(self, ratings: List[int]) -> int:
candyVec = [1] * len(ratings)
# 从前向后遍历,处理右侧比左侧评分高的情况
for i in range(1, len(ratings)):
if ratings[i] > ratings[i - 1]:
candyVec[i] = candyVec[i - 1] + 1
# 从后向前遍历,处理左侧比右侧评分高的情况
for i in range(len(ratings) - 2, -1, -1):
if ratings[i] > ratings[i + 1]:
candyVec[i] = max(candyVec[i], candyVec[i + 1] + 1)
# 统计结果
result = sum(candyVec)
return result
好题,要多练。注意点我已经写在了注释中。
注意遍历顺序与左右侧大小的关系,同时,第二个方向的取max操作也是精髓,必须要基于上一个candy的值进行判断。
class Solution:
def candy(self, ratings: List[int]) -> int:
n = len(ratings)
candy = [1] * n
# 一定要注意遍历顺序与左右侧大小的关系
# 从前向后,处理右侧评分比左边高的情况
for i in range(1,len(ratings)):
if ratings[i] > ratings[i-1]:
candy[i] = candy[i-1]+1
# 从后向前,处理左侧比右侧高的情况
for i in range(len(ratings)-2,-1,-1):
if ratings[i] > ratings[i+1]:
# 这里的max也是精髓,必须要基于前一个candy的值,不能是一个全新的[1]数组
candy[i] = max(candy[i+1]+1,candy[i])
res = sum(candy)
return res
首先能想到的是建立一个数组,因为只有三种面值,加减一就好了,一直遍历到数组结束,但是这种解法没有贪心的思想,顶多就是找零时,优先使用10元的。
本来以为有贪心,但是没想到就是我上面说的那样,而且贪心就体现在先用10元上。
class Solution:
def lemonadeChange(self, bills: List[int]) -> bool:
five = 0
ten = 0
twenty = 0
for bill in bills:
# 情况一:收到5美元
if bill == 5:
five += 1
# 情况二:收到10美元
if bill == 10:
if five <= 0:
return False
ten += 1
five -= 1
# 情况三:收到20美元
if bill == 20:
# 先尝试使用10美元和5美元找零
if five > 0 and ten > 0:
five -= 1
ten -= 1
#twenty += 1
# 如果无法使用10美元找零,则尝试使用三张5美元找零
elif five >= 3:
five -= 3
#twenty += 1
else:
return False
return True
class Solution:
def lemonadeChange(self, bills: List[int]) -> bool:
five = 0
ten = 0
twenty = 0
for bill in bills:
if bill == 5 :
five+=1
if bill == 10 :
if five <= 0:
return False
ten += 1
five-=1
if bill == 20 :
if ten > 0 and five > 0 :
ten -= 1
five -= 1
twenty += 1
elif five >= 3:
five -= 3
twenty += 1
else :
return False
return True
思路上还是出现了偏差。
首先要认识到,这也是一道双维度的题,类似于分发糖果。那么先处理哪一维度就很关键。
先处理K,按K排序,得到的既不满足K的约束,也不满足H。
所以应该先处理H,按H排序,然后处理K,对于同一K,先处理H大的。这点我倒是想到了。
按照K插入。K是多少就插入在哪个位置。
这题在代码逻辑上也不是那么好想的。
要点在于按身高H排序而不是K,因为排序后,身高一定是从小到大的,而对于K来说,也是一个和H相关的量,根据按顺序的H,K的插入位置可以随之确定。
class Solution:
def reconstructQueue(self, people: List[List[int]]) -> List[List[int]]:
# 先按照h维度的身高顺序从高到低排序。确定第一个维度
# lambda返回的是一个元组:当-x[0](维度h)相同时,再根据x[1](维度k)从小到大排序
people.sort(key=lambda x: (-x[0], x[1]))
que = []
# 根据每个元素的第二个维度k,贪心算法,进行插入
# people已经排序过了:同一高度时k值小的排前面。
for p in people:
que.insert(p[1], p)
return que
双维度,排序,插入!
class Solution:
def reconstructQueue(self, people: List[List[int]]) -> List[List[int]]:
# 先按照H维度,按身高从高到低排序,确定第一个维度
# 当身高相同时,按照第二个维度K排序,K小的排在前面
people.sort(key = lambda x : (-x[0],x[1]))
res = []
for p in people :
res.insert(p[1],p)
return res
贪心系列3总结
可以看看,虽然Python不涉及这些东西,但毕竟都是底层实现。
不会,也没思路,感觉又是两个维度?但是感觉从哪个维度排序都不对啊。
靠,原本我想的极端示例的例子,竟然按照最朴素的思想,就可以包括了,重叠后更新右边界的操作,是比较好想的,但如果不进行实际模拟,很难想到这种一般性的解法,可以解决极端示例。
极端示例(已经按第一维排序):[2,4] [2,3] [2,3] [4,7] [5,6] [5,6] 。
等等!但是这种情况,如果我在排序时,规定,如果第一维相同,按第二维从大到小排序不就好了吗!
况且!就算只按第一维排序,第二维为乱序,按照代码随想录所讲解的,更新右边界的朴素思想,也是正确的!
逻辑真难想啊。
本题贪心的思路不复杂,是我第一遍看题的时候,想的太复杂了!
class Solution:
def findMinArrowShots(self, points: List[List[int]]) -> int:
if len(points) == 0: return 0
points.sort(key=lambda x: x[0])
result = 1
for i in range(1, len(points)):
if points[i][0] > points[i - 1][1]: # 气球i和气球i-1不挨着,注意这里不是>=
result += 1
else:
points[i][1] = min(points[i - 1][1], points[i][1]) # 更新重叠气球最小右边界
return result
class Solution: # 不改变原数组
def findMinArrowShots(self, points: List[List[int]]) -> int:
points.sort(key = lambda x: x[0])
sl,sr = points[0][0],points[0][1]
count = 1
for i in points:
if i[0]>sr:
count+=1
sl,sr = i[0],i[1]
else:
sl = max(sl,i[0])
sr = min(sr,i[1])
return count
区间重叠的经典代码了。
class Solution:
def findMinArrowShots(self, points: List[List[int]]) -> int:
if len(points)==0 :
return 0
points.sort(key = lambda x :x[0])
result = 1
for i in range(1,len(points)):
if points[i][0] > points[i-1][1] :
result += 1
else :
points[i][1] = min(points[i][1],points[i-1][1])
return result
因为上一题刚学完箭,这一题可以直接现学现卖,思路还是先算射箭的最小数目,当然区间判断条件要稍微改动,加一个等号,然后,要删除的区间数量,就等于总数量减去箭的数量,箭的数量,就是我们去掉所有重复集合后,剩余的集合数量。
当然,不得不承认的是,如果不是因为上一题是箭,这个方法根本想不到。
class Solution:
def eraseOverlapIntervals(self, intervals: List[List[int]]) -> int:
if len(intervals) == 0: return 0
intervals.sort(key=lambda x: x[0])
result = 1
for i in range(1, len(intervals)):
if intervals[i][0] >= intervals[i - 1][1]:
result += 1
else:
intervals[i][1] = min(intervals[i - 1][1], intervals[i][1])
return len(intervals)-result
然后就是这种直接计算重叠区间的方法,贪心思想很直观,但是是不是最优解,就不知道了,反正能通过。
class Solution:
def eraseOverlapIntervals(self, intervals: List[List[int]]) -> int:
if len(intervals) == 0: return 0
intervals.sort(key=lambda x: x[0])
result = 0
for i in range(1, len(intervals)):
if intervals[i][0] < intervals[i - 1][1]:
intervals[i][1] = min(intervals[i - 1][1], intervals[i][1])
result += 1
return result
本题不管是,左边界排序,还是右边界排序,都是可以的。
按照代码随想录的说法,左边界排序,求的直接就是重叠区间个数;右边界排序,求的是非交叉区间的个数,但是我个人感觉,这里具体的意义,是和变量的定义相关的。
已经连续做了两道,和交叉区间,相关的题目,以后相关的题也是类似的解法。
这里放上代码随想录的解答链接,时时复习。
无重叠区间
贪心 基于左边界
class Solution:
def eraseOverlapIntervals(self, intervals: List[List[int]]) -> int:
if not intervals:
return 0
intervals.sort(key=lambda x: x[0]) # 按照左边界升序排序
count = 0 # 记录重叠区间数量
for i in range(1, len(intervals)):
if intervals[i][0] < intervals[i - 1][1]: # 存在重叠区间
intervals[i][1] = min(intervals[i - 1][1], intervals[i][1]) # 更新重叠区间的右边界
count += 1
return count
贪心 基于左边界 把452.用最少数量的箭引爆气球代码稍做修改
class Solution:
def eraseOverlapIntervals(self, intervals: List[List[int]]) -> int:
if not intervals:
return 0
intervals.sort(key=lambda x: x[0]) # 按照左边界升序排序
result = 1 # 不重叠区间数量,初始化为1,因为至少有一个不重叠的区间
for i in range(1, len(intervals)):
if intervals[i][0] >= intervals[i - 1][1]: # 没有重叠
result += 1
else: # 重叠情况
intervals[i][1] = min(intervals[i - 1][1], intervals[i][1]) # 更新重叠区间的右边界
return len(intervals) - result
关键在于理清逻辑,基于左边界,result从0开始计数,那么result代表的,就是重叠区间的个数,比如有3个重叠,result就是2,也就是要删除的区间的最小值。
class Solution:
def eraseOverlapIntervals(self, intervals: List[List[int]]) -> int:
if len(intervals) == 0: return 0
intervals.sort(key=lambda x: x[0])
result = 0
for i in range(1, len(intervals)):
if intervals[i][0] < intervals[i - 1][1]:
intervals[i][1] = min(intervals[i - 1][1], intervals[i][1])
result += 1
return result
看了看解答,和我自己的思路基本一致,不可避免地要去统计每一个字符的最后出现位置,要用一个额外的循环。
先去计算一个哈希数组,来保存每一个字符的最后出现位置。同样,这里想到用哈希数组也是一个小技巧。
贪心(版本一)
这个思路我已经想到了。
class Solution:
def partitionLabels(self, s: str) -> List[int]:
last_occurrence = {} # 存储每个字符最后出现的位置
for i, ch in enumerate(s):
last_occurrence[ch] = i
result = []
start = 0
end = 0
for i, ch in enumerate(s):
end = max(end, last_occurrence[ch]) # 找到当前字符出现的最远位置
if i == end: # 如果当前位置是最远位置,表示可以分割出一个区间
result.append(end - start + 1)
start = i + 1
return result
贪心(版本二)与452.用最少数量的箭引爆气球 (opens new window)、435.无重叠区间 (opens new window)相同的思路。
这种思路在逻辑上不直观。
class Solution:
def countLabels(self, s):
# 初始化一个长度为26的区间列表,初始值为负无穷
hash = [[float('-inf'), float('-inf')] for _ in range(26)]
hash_filter = []
for i in range(len(s)):
if hash[ord(s[i]) - ord('a')][0] == float('-inf'):
hash[ord(s[i]) - ord('a')][0] = i
hash[ord(s[i]) - ord('a')][1] = i
for i in range(len(hash)):
if hash[i][0] != float('-inf'):
hash_filter.append(hash[i])
return hash_filter
def partitionLabels(self, s):
res = []
hash = self.countLabels(s)
hash.sort(key=lambda x: x[0]) # 按左边界从小到大排序
rightBoard = hash[0][1] # 记录最大右边界
leftBoard = 0
for i in range(1, len(hash)):
if hash[i][0] > rightBoard: # 出现分割点
res.append(rightBoard - leftBoard + 1)
leftBoard = hash[i][0]
rightBoard = max(rightBoard, hash[i][1])
res.append(rightBoard - leftBoard + 1) # 最右端
return res
学习这种思路,重点在于先求哈希表以及max更新的操作。
class Solution:
def partitionLabels(self, s: str) -> List[int]:
last_occurence = {}
for i,ch in enumerate(s):
last_occurence[ch]=i
res = []
start = 0
end = 0
for i,ch in enumerate(s):
end = max(end,last_occurence[ch])
if i==end :
res.append(end-start+1)
start = i+1
return res
Debug了三次,通过。通过找Bug,注意点我已经写在注释了。
总结下来主要就是:不要忘记排序,注意append逻辑的位置,注意更改右区间。
class Solution:
def merge(self, intervals: List[List[int]]) -> List[List[int]]:
# 细节一:记得先排序
intervals.sort(key=lambda x: x[0])
res = []
for i in range(len(intervals)-1):
if intervals[i][1] >= intervals[i+1][0] :
# 细节2:不要把append放在这里,逻辑会乱掉,如果能合并,就在intervals里面修改
# 修改区间去必须的,当不满足条件时,再append,自然就是合并后的区间了
# res.append([intervals[i][0],intervals[i+1][1]])
intervals[i+1][0] = intervals[i][0]
# 可能存在上一个区间包含了下一个区间的情况,所以这里不仅要变化左区间,也要变化右区间
# 变化右区间的思想,是在前面的题中已经涉及的,所以本题的新地方反倒是最容易想到的修改左值
# 还是对右区间的改变掌握不到位
intervals[i+1][1] = max(intervals[i+1][1],intervals[i][1])
else :
res.append(intervals[i])
res.append(intervals[-1])
return res
但凡是做重叠区间的题,第一件事,一定是让重叠的区间尽可能挨在一起,所以要先排序!
在区间处理上和我写的略有不同,代码随想录是先放入res数组,然后取区间和比较,均从res数组的最后一个元素取。理解下来,觉得这种方法可能更好一点。
class Solution:
def merge(self, intervals):
result = []
if len(intervals) == 0:
return result # 区间集合为空直接返回
intervals.sort(key=lambda x: x[0]) # 按照区间的左边界进行排序
result.append(intervals[0]) # 第一个区间可以直接放入结果集中
for i in range(1, len(intervals)):
if result[-1][1] >= intervals[i][0]: # 发现重叠区间
# 合并区间,只需要更新结果集最后一个区间的右边界,因为根据排序,左边界已经是最小的
result[-1][1] = max(result[-1][1], intervals[i][1])
else:
result.append(intervals[i]) # 区间不重叠
return result
我觉得自己写的这一版也挺好的。
class Solution:
def merge(self, intervals: List[List[int]]) -> List[List[int]]:
# 细节一:记得先排序
intervals.sort(key=lambda x: x[0])
res = []
for i in range(len(intervals)-1):
if intervals[i][1] >= intervals[i+1][0] :
# 细节2:不要把append放在这里,逻辑会乱掉,如果能合并,就在intervals里面修改
# 修改区间去必须的,当不满足条件时,再append,自然就是合并后的区间了
# res.append([intervals[i][0],intervals[i+1][1]])
intervals[i+1][0] = intervals[i][0]
# 可能存在上一个区间包含了下一个区间的情况,所以这里不仅要变化左区间,也要变化右区间
# 变化右区间的思想,是在前面的题中已经涉及的,所以本题的新地方反倒是最容易想到的修改左值
# 还是对右区间的改变掌握不到位
intervals[i+1][1] = max(intervals[i+1][1],intervals[i][1])
else :
res.append(intervals[i])
res.append(intervals[-1])
return res
代码随想录的版本
class Solution:
def merge(self, intervals: List[List[int]]) -> List[List[int]]:
result = []
if len(intervals)==0 :
return res
intervals.sort(key=lambda x : x[0])
result.append(intervals[0])
for i in range(1,len(intervals)):
if result[-1][1] >= intervals[i][0] :
result[-1][1] = max(result[-1][1],intervals[i][1])
else:
result.append(intervals[i])
return result
本周的题,总的来说,都是求解重叠区间的类型,这类题我现在理解的有两个注意点。一是一定要先排序,并且可以统一就用左区间排序,不管什么问题,都用左区间排序。二是,一定要记得,在每次判断中,都要去修改右边界的值。放上代码随想录总结的链接如下。
贪心系列总结3
没思路,总能想出一些特殊情形,处理不了。
牛逼!这题的精妙点在于遍历顺序上。我一直先入为主,使用前序遍历,怪不得怎么想都不对!
要用后序遍历!做了这道题之后,也该有后序遍历的思维了!
还有一个很厉害的点,虽然本题的主要逻辑是,如果前一位大于后一位,比如32,就让前一位减一,后一位变为9,但是在处理中不能这样写,而是要用一个flag变量,来记录一个index,该index以后的位置,全部变成9。因为反例:1000,后面两个0是不比较的,因为比较逻辑是小于,不包括等于,不用flag,结果会是900,是错误的。
暴力:会超时
class Solution:
def checkNum(self, num):
max_digit = 10
while num:
digit = num % 10
if max_digit >= digit:
max_digit = digit
else:
return False
num //= 10
return True
def monotoneIncreasingDigits(self, N):
for i in range(N, 0, -1):
if self.checkNum(i):
return i
return 0
贪心(版本一)
class Solution:
def monotoneIncreasingDigits(self, N: int) -> int:
# 将整数转换为字符串
strNum = str(N)
# flag用来标记赋值9从哪里开始
# 设置为字符串长度,为了防止第二个for循环在flag没有被赋值的情况下执行
flag = len(strNum)
# 从右往左遍历字符串
for i in range(len(strNum) - 1, 0, -1):
# 如果当前字符比前一个字符小,说明需要修改前一个字符
if strNum[i - 1] > strNum[i]:
flag = i # 更新flag的值,记录需要修改的位置
# 将前一个字符减1,以保证递增性质
strNum = strNum[:i - 1] + str(int(strNum[i - 1]) - 1) + strNum[i:]
# 将flag位置及之后的字符都修改为9,以保证最大的递增数字
for i in range(flag, len(strNum)):
strNum = strNum[:i] + '9' + strNum[i + 1:]
# 将最终的字符串转换回整数并返回
return int(strNum)
代码随想录给出的其他几个版本的贪心算法,我看了看在基本思路上没有变化,改变的只有编写代码的技巧,但是我觉得不如最基础的这一版好理解,而且也并没有使代码简洁或高效,所以后面我觉得也不用关注这些版本了。
这份代码也是要学习的。
class Solution:
def monotoneIncreasingDigits(self, n: int) -> int:
# 将整数转换为字符串
strnum = str(n)
# flag用于记录从哪里全赋值为9,同时应初始化为字符串长度
flag = len(strnum)
# 倒序,从右向左遍历,很重要
# 注意循环的起始和结束
for i in range(len(strnum)-1,0,-1):
if strnum[i-1] > strnum[i] :
flag = i # 记录9需要修改的位置
# 这里只将前一个字符减1
strnum = strnum[:i-1]+str(int(strnum[i-1])-1)+strnum[i:]
for i in range(flag, len(strnum)):
strnum = strnum[:i] + '9' + strnum[i + 1:]
return int(strnum)
一点思路没有。
首先确定二叉树的遍历顺序,一定是后序遍历,因为要先处理叶子节点,往叶子节点的父节点,优先放摄像头。每隔两个节点,放置一个摄像头。
理清每个节点的三种状态,无覆盖,有摄像头,有覆盖。
接着就要判断:空节点是上述三个状态的哪个状态?根据排除法,空节点只能是“有覆盖”的状态。
在递归逻辑中,主要有以下四种情况:
情况1:左右节点都有覆盖
情况2:左右节点至少有一个无覆盖的情况
情况3:左右节点至少有一个有摄像头
情况4:头结点没有覆盖
主要思想:根据左右孩子的状态,来决定其父节点的状态。
贪心(版本一)
class Solution:
# Greedy Algo:
# 从下往上安装摄像头:跳过leaves这样安装数量最少,局部最优 -> 全局最优
# 先给leaves的父节点安装,然后每隔两层节点安装一个摄像头,直到Head
# 0: 该节点未覆盖
# 1: 该节点有摄像头
# 2: 该节点有覆盖
def minCameraCover(self, root: TreeNode) -> int:
# 定义递归函数
result = [0] # 用于记录摄像头的安装数量
if self.traversal(root, result) == 0:
result[0] += 1
return result[0]
def traversal(self, cur: TreeNode, result: List[int]) -> int:
if not cur:
return 2
left = self.traversal(cur.left, result)
right = self.traversal(cur.right, result)
# 情况1: 左右节点都有覆盖
if left == 2 and right == 2:
return 0
# 情况2:
# left == 0 && right == 0 左右节点无覆盖
# left == 1 && right == 0 左节点有摄像头,右节点无覆盖
# left == 0 && right == 1 左节点无覆盖,右节点有摄像头
# left == 0 && right == 2 左节点无覆盖,右节点覆盖
# left == 2 && right == 0 左节点覆盖,右节点无覆盖
if left == 0 or right == 0:
result[0] += 1
return 1
# 情况3:
# left == 1 && right == 2 左节点有摄像头,右节点有覆盖
# left == 2 && right == 1 左节点有覆盖,右节点有摄像头
# left == 1 && right == 1 左右节点都有摄像头
if left == 1 or right == 1:
return 2
贪心(版本二)利用elif精简代码
不推荐,条件判断不清晰。
class Solution:
# Greedy Algo:
# 从下往上安装摄像头:跳过leaves这样安装数量最少,局部最优 -> 全局最优
# 先给leaves的父节点安装,然后每隔两层节点安装一个摄像头,直到Head
# 0: 该节点未覆盖
# 1: 该节点有摄像头
# 2: 该节点有覆盖
def minCameraCover(self, root: TreeNode) -> int:
# 定义递归函数
result = [0] # 用于记录摄像头的安装数量
if self.traversal(root, result) == 0:
result[0] += 1
return result[0]
def traversal(self, cur: TreeNode, result: List[int]) -> int:
if not cur:
return 2
left = self.traversal(cur.left, result)
right = self.traversal(cur.right, result)
# 情况1: 左右节点都有覆盖
if left == 2 and right == 2:
return 0
# 情况2:
# left == 0 && right == 0 左右节点无覆盖
# left == 1 && right == 0 左节点有摄像头,右节点无覆盖
# left == 0 && right == 1 左节点无覆盖,右节点有摄像头
# left == 0 && right == 2 左节点无覆盖,右节点覆盖
# left == 2 && right == 0 左节点覆盖,右节点无覆盖
elif left == 0 or right == 0:
result[0] += 1
return 1
# 情况3:
# left == 1 && right == 2 左节点有摄像头,右节点有覆盖
# left == 2 && right == 1 左节点有覆盖,右节点有摄像头
# left == 1 && right == 1 左右节点都有摄像头
else:
return 2
这道题真的很难。
class Solution:
def minCameraCover(self, root: Optional[TreeNode]) -> int:
result = [0]
if self.traversal(root,result)==0:
result[0]+=1
return result[0]
def traversal(self,cur,result):
if not cur :
return 2
left = self.traversal(cur.left,result)
right = self.traversal(cur.right,result)
if left==2 and right==2 :
return 0
if left == 0 or right == 0:
result[0]+=1
return 1
if left == 1 or right == 1:
return 2
好好好!复习贪心的大纲!贪心的中等题和难题一定要多练。
贪心系列大总结