您现在的位置是:首页 >学无止境 >《算法通关之路》-chapter5二分法网站首页学无止境
《算法通关之路》-chapter5二分法
《算法通关之路》学习笔记,记录一下自己的刷题过程,详细的内容请大家购买作者的书籍查阅。
二分查找
力扣第704题
给定一个 n 个元素有序的(升序)整型数组 nums 和一个目标值 target ,写一个函数搜索 nums 中的 target,如果目标值存在返回下标,否则返回 -1。
'''
方法一:递归
时间复杂度:O(logn)
空间复杂度:O(logn)
'''
class Solution:
def search(self, nums: list[int], target: int) -> int:
left, right = 0, len(nums) - 1
def binary_search(left: int, right: int, target: int) -> int:
if left > right:
return -1
mid = (left + right) // 2
if nums[mid] == target:
return mid
elif nums[mid] > target:
return binary_search(left, mid - 1, target)
else:
return binary_search(mid + 1, right, target)
return binary_search(left, right, target)
nums, target = [-1,0,3,5,9,12], 9
solu = Solution()
solu.search(nums, target)
'''
方法一:迭代
时间复杂度:O(logn)
空间复杂度:O(1)
'''
class Solution:
def search(self, nums: list[int], target: int) -> int:
left, right = 0, len(nums)-1
while left <= right :
mid = (left + right) // 2
if nums[mid] == target:
return mid
elif nums[mid] > target:
right = mid - 1
else:
left = mid + 1
return -1
nums, target = [-1,0,3,5,9,12], 9
solu = Solution()
solu.search(nums, target)
寻找旋转排序数组中的最小值
力扣第153题
已知一个长度为 n 的数组,预先按照升序排列,经由 1 到 n 次 旋转 后,得到输入数组。例如,原数组 nums = [0,1,2,4,5,6,7] 在变化后可能得到:
若旋转 4 次,则可以得到 [4,5,6,7,0,1,2]
若旋转 7 次,则可以得到 [0,1,2,4,5,6,7]
注意,数组 [a[0], a[1], a[2], …, a[n-1]] 旋转一次 的结果为数组 [a[n-1], a[0], a[1], a[2], …, a[n-2]] 。
给你一个元素值 互不相同 的数组 nums ,它原来是一个升序排列的数组,并按上述情形进行了多次旋转。请你找出并返回数组中的 最小元素 。
你必须设计一个时间复杂度为 O(log n) 的算法解决此问题。
'''
方法一:二分法
时间复杂度:O(logn)
空间复杂度:O(1)
'''
class Solution:
def findMin(self, nums: list[int]) -> int:
left, right = 0, len(nums) - 1
while left <= right:
mid = left + (right - left) // 2
if left == right:
return nums[mid]
if nums[mid] > nums[right]:
left = mid + 1
elif nums[mid] < nums[right]:
right = mid
return -1
nums = [3,4,5,1,2]
solu = Solution()
solu.findMin(nums)
爱吃香蕉的珂珂
力扣第875题
珂珂喜欢吃香蕉。这里有 n 堆香蕉,第 i 堆中有 piles[i] 根香蕉。警卫已经离开了,将在 h 小时后回来。
珂珂可以决定她吃香蕉的速度 k (单位:根/小时)。每个小时,她将会选择一堆香蕉,从中吃掉 k 根。如果这堆香蕉少于 k 根,她将吃掉这堆的所有香蕉,然后这一小时内不会再吃更多的香蕉。
珂珂喜欢慢慢吃,但仍然想在警卫回来前吃掉所有的香蕉。
返回她可以在 h 小时内吃掉所有香蕉的最小速度 k(k 为整数)。
'''
方法一:二分法
时间复杂度:O(mlogn)
空间复杂度:O(1)
'''
import math
class Solution:
def minEatingSpeed(self, piles: list[int], h: int) -> int:
def eat(k, h):
need_h = 0
for pile in piles:
need_h += math.ceil(pile / k)
return need_h <= h
res = -1
left, right = 1, max(piles)
while left <= right:
mid = left + (right - left) // 2
if eat(mid, h):
res = mid
right = mid - 1
else:
left = mid + 1
return res
piles, h = [3,6,7,11], 8
solu = Solution()
solu.minEatingSpeed(piles, h)
二分查找的变种(防止死循环)
# 1. 在排序数组中找到第一个大于或等于x的元素,该元素必定存在
def bs(nums, x):
l, h = 0, len(nums) - 1
while l <= h:
mid = l + (h - l) // 2
if l == h:
break
elif nums[mid] >= x:
h = mid
else:
l = mid + 1
# 2. 在排序数组里找到最后一个小于或等于x的元素,该元素必定存在
def bs(nums, x):
l, h = 0, len(nums) - 1
while l <= h:
mid = l + (h - l) // 2
if l == h or l + 1 == h:
break
elif nums[mid] <= x:
l = mid
else:
h = mid - 1
return nums[h] if nums[h] <= x else nums[l]
x 的平方根
力扣第69题
给你一个非负整数 x ,计算并返回 x 的 算术平方根 。
由于返回类型是整数,结果只保留 整数部分 ,小数部分将被 舍去 。
注意:不允许使用任何内置指数函数和算符,例如 pow(x, 0.5) 或者 x ** 0.5 。
'''
方法一:二分法
时间复杂度:O(logn)
空间复杂度:O(1)
'''
class Solution:
def mySqrt(self, x: int) -> int:
l, r, ans = 0, x, -1
while l <= r:
mid = (l + r) // 2
if mid * mid <= x:
ans = mid
l = mid + 1
else:
r = mid - 1
return ans
x = 8
solu = Solution()
solu.mySqrt(x)
寻找峰值
力扣第162题
峰值元素是指其值严格大于左右相邻值的元素。
给你一个整数数组 nums,找到峰值元素并返回其索引。数组可能包含多个峰值,在这种情况下,返回 任何一个峰值 所在位置即可。
你可以假设 nums[-1] = nums[n] = -∞ 。
你必须实现时间复杂度为 O(log n) 的算法来解决此问题。
'''
方法一:二分法
时间复杂度:O(logn)
空间复杂度:O(1)
'''
class Solution:
def findPeakElement(self, nums: list[int]) -> int:
left, right = 0, len(nums) - 1
while left <= right:
mid = left + (right - left) // 2
if mid + 1 < len(nums) and nums[mid] < nums[mid + 1]:
left = mid + 1
elif mid > 0 and nums[mid] < nums[mid - 1]:
right = mid - 1
else:
return mid
return -1
nums = [1,2,3,1]
solu = Solution()
solu.findPeakElement(nums)
分割数组的最大值
力扣第410题
给定一个非负整数数组 nums 和一个整数 m ,你需要将这个数组分成 m 个非空的连续子数组。
设计一个算法使得这 m 个子数组各自和的最大值最小。
'''
方法一:二分+贪心
时间复杂度:O(nlogm)
空间复杂度:O(1)
'''
class Solution:
def splitArray(self, nums: list[int], k: int) -> int:
left, right = max(nums), sum(nums)
def helper(ans: int) -> bool:
cnt, cur = 1, 0
for num in nums:
if cur + num > ans:
cur = num
cnt += 1
else:
cur += num
return cnt <= k
while left <= right:
mid = left + (right - left) // 2
if left == right:
return left
elif helper(mid):
right = mid
else:
left = mid + 1
return -1
nums, m = [7,2,5,10,8], 2
solu = Solution()
solu.splitArray(nums, m)
逆向思维二分法求解模板
def helper(x):
# 判断是否可行的函数
# 搜索区间
l, h = max(nums), sum(nums)
# 根据实际情况调整二分逻辑
# 这里情况可以是找任意满足条件的值、最左满足条件的值,最右满足条件的值等
while l <= h:
mid = l + (h - l) // 2
if l == h:
return l
elif helper(mid):
h = mid
else:
l = mid + 1
return -1