算法套路三:二分查找——红蓝染色法

Pistachiout

已于 2023-06-08 20:48:45 修改

阅读量1.4k

点赞数 4

分类专栏： # 算法套路文章标签：算法 leetcode 数据结构

于 2023-03-14 20:22:55 首次发布

本文链接：https://blog.csdn.net/qq_45808700/article/details/129247507

版权

算法套路专栏收录该内容

20 篇文章 6 订阅

订阅专栏

算法套路三:二分查找——红蓝染色法

套路示例：LeetCode34. 在排序数组中查找元素的第一个和最后一个位置

给你一个按照非递减顺序排列的整数数组 nums，和一个目标值 target。请你找出给定目标值在数组中的开始位置和结束位置。如果数组中不存在目标值 target，返回 [-1, -1]。你必须设计并实现时间复杂度为 O(log n) 的算法解决此问题。

二分查找本身并不复杂，但在写代码时往往会出现问题，比如出现死循环，不知道如何初始化，不知道为什么有时left=mid，有时left=mid+1，有时会莫名其妙把某个数排除，那么看完这个套路课你都懂了

首先是循环不变量
以示例一为例：
L和R分别指向询问的左右边界，即闭区间[L, R]M指向当前正在询问的数，且红蓝染色法，即左红右蓝
若是升序排列则：

蓝色背景表示 true，即≥target
红色背景表示false，即<target
白色背景表示不确定

在这里插入图片描述

right 左移使右侧变蓝 (判断条件为 true )
left 右移使左侧变红 (判断条件为 false )
闭区间时，L-1必定是红色即false，R+1必定是蓝色即true，这就是循环不变量

二分查找分三种写法，分别是：

闭区间写法

# lower_bound 返回最小的满足 nums[i] >= target 的 i
# 如果数组为空，或者所有数都 < target，则返回 len(nums)
# 要求 nums 是非递减的，即 nums[i] <= nums[i + 1]

# 
def lower_bound(nums: List[int], target: int) -> int:
    left, right = 0, len(nums) - 1  # 闭区间 [left, right]
    while left <= right:  # 区间不为空
        # 循环不变量：left-1与right+1
        # nums[left-1] < target
        # nums[right+1] >= target
        mid = (left + right) // 2
        if nums[mid] < target:
            left = mid + 1  # 范围缩小到 [mid+1, right]
        else:
            right = mid - 1  # 范围缩小到 [left, mid-1]
    return left  # 或者 right+1

class Solution:
    def searchRange(self, nums: List[int], target: int) -> List[int]:
        start = lower_bound(nums, target)  # 选择其中一种写法即可
        if start == len(nums) or nums[start] != target:
            return [-1, -1]
        # 如果 start 存在，那么 end 必定存在
        end = lower_bound(nums, target + 1) - 1
        return [start, end]

左闭右开区间写法

def lower_bound2(nums: List[int], target: int) -> int:
    left = 0
    right = len(nums)  # 左闭右开区间 [left, right)
    while left < right:  # 区间不为空
        # 循环不变量：left-1与right
        # nums[left-1] < target
        # nums[right] >= target
        mid = (left + right) // 2
        if nums[mid] < target:
            left = mid + 1  # 范围缩小到 [mid+1, right)
        else:
            right = mid  # 范围缩小到 [left, mid)
    return left  # 或者 right

开区间写法


def lower_bound3(nums: List[int], target: int) -> int:
    left, right = -1, len(nums)  # 开区间 (left, right)
    while left + 1 < right:  # 区间不为空
        mid = (left + right) // 2
        # 循环不变量：left与right
        # nums[left] < target
        # nums[right] >= target
        if nums[mid] < target:
            left = mid  # 范围缩小到 (mid, right)
        else:
            right = mid  # 范围缩小到 (left, mid)
    return right  # 或者 left+1

有序数组中二分查找的四种类型（下面的转换仅适用于数组中都是整数），lower_bound返回下标
第一个大于等于x的下标： low_bound(x)
第一个大于x的下标：可以转换为第一个大于等于 x+1 的下标 ，low_bound(x+1)
最后一个一个小于x的下标：可以转换为数组中第一个大于等于 x 的下标 的左边位置, low_bound(x) - 1;
最后一个小于等于x的下标：可以转换为数组中第一个大于等于 x+1 的下标 的 左边位置, low_bound(x+1) - 1;

套路总结

红蓝染色法

left指针掌管左边蓝色区域，蓝色表示 truej即所求值及其右侧，right指针掌管右边红色区域，红色表示false即所求值左侧，两者互不冲突，通过不断向目标区域靠近，扩大两个指针的掌管区域，直到两者掌管的区域接壤
使用闭区间时，L-1必定是红色即false，R+1必定是蓝色即true，这就是循环不变量
关键不在于区间里的元素具有什么性质，而是区间外面的元素具有什么性质，即将区间外染成红色与蓝色。
根据以上两点，在做题时关键即确定二分条件函数isBlue()，判断是否满足条件，满足条件则right 左移使右侧变蓝 ，不满足条件则left 右移使左侧变红

代码规范

注意代码区间开闭写法，之前提过的在LeetCode题解中大家看到的left与right取初值有时不一样，在二分时left指针有时等于mid+1有时等于mid，这是区间开闭的问题，不必纠结太多，三种都可以，我习惯于使用闭区间
如果找不到比较元素，则可将数组最后一个元素单独提出作为比较元素，且right=n-2，因为若最后一个元素为所查找元素，二分查找时left也可以超出right=n-2的范围找到该元素；若不是所查找元素，单独提出也没有影响.
根据上一点就明白为什么有时LeetCode题解在二分前就去掉了数组某个元素，这不会影响最终结果，可能是因为能判断这个元素不是所求结果，或者这个结果在最后一次循环时能够遍历到（闭区间时left能够遍历到数组长度+1）

练习LeetCode162. 寻找峰值

峰值元素是指其值严格大于左右相邻值的元素。
给你一个整数数组 nums，找到峰值元素并返回其索引。数组可能包含多个峰值，在这种情况下，返回任何一个峰值所在位置即可。你可以假设 nums[-1] = nums[n] = -∞ 。你必须实现时间复杂度为 O(log n) 的算法来解决此问题。对于所有有效的 i 都有 nums[i] != nums[i + 1]

已知nums[i] != nums[i + 1]，那么我比较nums[i] 与nums[i + 1]，且将最后一个元素提出，防止nums[i + 1]数组越界，而若该元素是峰值，left在最后一次循环时能是left=n-1找到，若不是峰值，则不需要遍历该元素

func findPeakElement(nums []int) int {
    left:=0
    right:=len(nums)-2
    for left<=right{
        mid:=left+(right-left)/2
        if nums[mid]<nums[mid+1]{
            left=mid+1
        }else{
            right=mid-1
        }
    }
    return left
}

练习LeetCode153. 寻找旋转排序数组中的最小值

已知一个长度为 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) 的算法解决此问题。

在这里插入图片描述
我们考虑数组中的最后一个元素 x即nums[len-1]：在最小值右侧的元素，它们的值一定都小于等于 x；而在最小值左侧的元素，它们的值一定都大于等于 x,通过与最后一个元素x比较，可以知道是前半段还是后半段升序数组。

如果nums[mid]>nums[n-1]，那么mid指向最小值左边，即最小值在mid右边，故去掉左半边，left=mid+1
如果nums[mid]<nums[n-1]，那么mid指向最小值右边，即最小值在mid左边，故去掉右半边，right=mid-1

func findMin(nums []int) int {
    n:=len(nums)
    l,r:=0,n-2
    for l<=r{
        mid:=l+(r-l)/2
        if nums[mid]>nums[n-1]{
            l=mid+1
        }else{
            r=mid-1
        }
    }
    return nums[l]
}

进阶LeetCode154. 寻找旋转排序数组中的最小值 II

已知一个长度为 n 的数组，预先按照升序排列，经由 1 到 n 次旋转后，得到输入数组。例如，原数组 nums =
[0,1,4,4,5,6,7] 在变化后可能得到：若旋转 4 次，则可以得到 [4,5,6,7,0,1,4] 若旋转 7 次，则可以得到
[0,1,4,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
，它原来是一个升序排列的数组，并按上述情形进行了多次旋转。请你找出并返回数组中的最小元素。你必须尽可能减少整个过程的操作步骤。这道题与LeetCode 153寻找旋转排序数组中的最小值类似，但 nums 可能包含重复元素。

前两种情况与上一题一样，
第三种情况是 nums[mid]==nums[high-1]。如下图所示，由于重复元素的存在，并不能确定 nums[mid] 究竟在最小值的左侧还是右侧，不能随意二分。但它们的值相同，所以无论nums[high] 是不是最小值，都有一个它的「替代品」nums[mid]。因此我们可以忽略二分查找区间的右端点，即high--。
如下图中随着high不断减少，必会使得 nums[mid]>nums[high]，此时即可继续二分
在这里插入图片描述
且由于数组最后一个元素可能有重复值影响二分，我们在比较时选择nums[right+1]即二分后数组的最右侧元素，即使存在重复值，随着right–，该值也会随之变化

func findMin(nums []int) int {
    left, right := 0, len(nums)-2
    for left <= right { 
        mid := left + (right-left)/2
        if nums[mid] < nums[right+1] { // 蓝色
            right = mid-1
        } else if nums[mid] > nums[right+1] { // 红色
            left = mid+1
        } else {
            right--
        }
    }
    return nums[left]
}

进阶LeetCode33. 搜索旋转排序数组

整数数组 nums 按升序排列，数组中的值互不相同。在传递给函数之前，nums 在预先未知的某个下标 k（0 <= k <
nums.length）上进行了旋转，使数组变为 [nums[k], nums[k+1], …, nums[n-1],
nums[0], nums[1], …, nums[k-1]]（下标从 0 开始计数）。例如， [0,1,2,4,5,6,7]
在下标 3 处经旋转后可能变为 [4,5,6,7,0,1,2] 。给你旋转后的数组 nums 和一个整数 target ，如果 nums
中存在这个目标值 target ，则返回它的下标，否则返回 -1 。你必须设计一个时间复杂度为 O(log n) 的算法解决此问题。

法一：两次二分查找

在这里插入图片描述
我们并不知道target是在左侧还是在右侧递增数组，但我们可以先根据LeetCode153.二分查找最小值将最小值索引minIndex找出，找出后比较target与数组最后一个元素，就可以知道target到底是在最小值左边或右边，然后在这一段进行二分查找找出target

func findMin(nums []int) int {
  left, right := 0, len(nums)-2 // 闭区间 [0, n-1]
  for left <= right {           // 当区间为空时终止
    mid := left + (right-left)/2 // 计算中间位置
    if nums[mid] < nums[len(nums)-1] { // 蓝色
      right = mid-1 // 更新右边界
    } else { // 红色
      left = mid + 1 // 更新左边界
    }
  }
  return left
}

func lowerBound(nums []int, left, right, target int) int {
  r0 := right
  for left <= right {           // 当区间为空时终止
    mid := left + (right-left)/2 // 计算中间位置
    if nums[mid] < target {
      left = mid + 1 // 更新左边界
    } else {
      right = mid - 1 // 更新右边界
    }
  }
  if left == r0+1 || nums[left] != target {
    return -1
  }
  return left
}

func search(nums []int, target int) int {
  i := findMin(nums)
  if target > nums[len(nums)-1] {
    return lowerBound(nums, 0, i-1, target) // 左段
  }
  return lowerBound(nums, i, len(nums)-1, target) // 右段
}

法二：一次二分查找

根据前一种方法，我们可以知道关键在于target是在最小值左侧还是右侧，那么可以只用一次二分查找即可，思路如下
定义函数isBlue，判断当前节点i是否为蓝色。若返回true，说明为蓝色，则右指针左移;若返回false，则左指针右移

若mid的值大于数组最后一个元素end，我们可知mid此时在最小值左侧，那么此时假设target的位置，考虑若target在mid左侧即mid为蓝色，此时必须满足target>end且nums[mid]>= target，如图所示；若不满足则为红色，故返回target > end && nums[i] >= target

在这里插入图片描述

若mid的值小于数组最后一个元素end，我们可知mid此时在最小值右侧，那么此时假设target的位置，考虑若target在mid右侧即mid为红色，此时必须满足target<end且nums[mid] <target，如图所示；若不满足则为蓝色，故返回！(target <= end && nums[i] < target)

在这里插入图片描述
由上可知，这就是红蓝染色法的关键应用点，我们可以将判断left与right谁移动抽象为函数isBlue（），然后假设此时mid为蓝色，此时得出num[mid]即target应该满足的条件，然后根据条件来进行判断返回是否为蓝色。

func search(nums []int, target int) int {
    isBlue := func(i int) bool {
        end := nums[len(nums)-1]
        if nums[i] > end {
            return target > end && nums[i] >= target
        } else {
            return !(target <= end && nums[i] < target)
        }
    }
    left, right := 0, len(nums)-2 
    for left <= right { 
        mid := left + (right-left)/2
        if isBlue(mid) { // 蓝色
            right = mid-1
        } else { // 红色
            left = mid+1
        }
    }
    if left == len(nums) || nums[left] != target {
        return -1
    }
    return left
}

Pistachiout

关注

4
点赞
踩
6

收藏

觉得还不错? 一键收藏
打赏
1
评论
算法套路三:二分查找——红蓝染色法

left指针掌管左边蓝色区域，蓝色表示 truej即所求值及其右侧，right指针掌管右边红色区域，红色表示false即所求值左侧，两者互不冲突，通过不断向目标区域靠近，扩大两个指针的掌管区域，直到两者掌管的区域接壤使用闭区间时，L-1必定是红色即false，R+1必定是蓝色即true，这就是循环不变量关键不在于区间里的元素具有什么性质，而是区间外面的元素具有什么性质，即将区间外染成红色与蓝色。根据以上两点，在做题时关键即确定二分条件函数isBlue()
复制链接

扫一扫