Leetcode编程实践-查找-滑动数组&二分查找

5.1 滑动数组算法应用

Leetcode219 存在重复元素2

给定一个整数数组和一个整数 k，判断数组中是否存在两个不同的索引 i 和 j，使得 nums [i] = nums [j]，并且 i 和 j 的差的 绝对值 至多为 k。

【思路】
使用长度为k的滑动窗口查找，若窗口内去重元素小于k，则返回true，否则继续滑动。

class Solution:
    def containsNearbyDuplicate(self, nums: List[int], k: int) -> bool:
        record=set() # 滑动窗口元素集合
        for i in range(len(nums)):
            if nums[i] in record: 
                return True
            record.add(nums[i])
            if len(record)>k: # 当集合元素超出k时，删除最左侧元素，向右滑动
                record.remove(nums[i-k])
        return False

Leetcode220 存在重复元素3

在整数数组 nums 中，是否存在两个下标 i 和 j，使得 nums [i] 和 nums [j] 的差的绝对值小于等于 t ，且满足 i 和 j 的差的绝对值也小于等于 ķ 。
如果存在则返回 true，不存在返回 false。

【思路】
暴力法：两重循环O(n^2)
二分查找法：目标数字区间为v-t<=x<=v+t，因为集合为有序数组，故可以使用二分查找（有序就想到二分查找）对record进行查找，先查找大于等于下界的最小数，在判断是否小于等于上界。

class Solution:
    def containsNearbyAlmostDuplicate(self, nums: List[int], k: int, t: int) -> bool:
        record=set() # 滑动窗口集合
        for i in range(len(nums)):
            if len(record)>0:
                r=list(record)
                idx=self.get(r,nums[i]-t) # 对集合进行二分查找，查找大于等于下界最小元素的坐标
                if idx!=-1 and r[idx]<=nums[i]+t: # 在判断是否小于等于上界
                    return True
            record.add(nums[i])
            if len(record)>k:
                record.remove(nums[i-k])
        return False
    # 二分查找函数
    def get(self,l,t):
        i,j=0,len(l)-1
        while i<j:
            mid=(j+i)//2 # 临界点
            if l[mid]<t:
                i=mid+1
            else:
                j=mid
        return i if l[i]>=t else -1 # 若集合中无目标数字，则返回-1

5.2 二分查找代码模板

def erfen(arr):
	# 低一点
	i,j = 0, len(arr)-1
	while i<j:
		mid = (i+j)//2
		# 第二点
		if f(x):
			i=mid+1
		else:
			j=mid
	return i

【解释】
第一点：i 和 j 分别对应搜索的上界和下界，但不一定为0和arr最后一个点的下标；
第二点：f(x) 为查找条件，带入模板即可。

5.3 二分查找应用

Leetcode35 搜索插入位置

给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。
你可以假设数组中无重复元素。

【思路】
排序数组→二分查找

class Solution:
    def searchInsert(self, nums: List[int], target: int) -> int:
        i,j=0,len(nums) # 此处末端设为len(nums) 是由于插入的数字为最大值 需要插入在最外面
        while i<j:
            m=(i+j)//2
            if nums[m]==target:
                return m
            elif nums[m]>target:
                j=m
            else: 
                i=m+1
        return i

Leetcode540 有序数组中的单一元素

给定一个只包含整数的有序数组，每个元素都会出现两次，唯有一个数只会出现一次，找出这个数。

【思路】
二分查找，若子集长度为单数则存在单一元素，对于该子集调用递归函数继续查找。

class Solution:
    def singleNonDuplicate(self, nums: List[int]) -> int:
        if len(nums)==1: return nums[0] # 边界条件
        i,j=0,len(nums)-1
        m=(i+j)//2
        if nums[m]!=nums[m-1] and nums[m]!=nums[m+1]: 
            return nums[m]
        elif nums[m]==nums[m+1]:
            if m%2==1:
                return self.singleNonDuplicate(nums[:m])
            else:
                return self.singleNonDuplicate(nums[m+2:])
        elif nums[m]==nums[m-1]:
            if (m-1)%2==1:
                return self.singleNonDuplicate(nums[:m-1])
            else:
                return self.singleNonDuplicate(nums[m+1:])

Leetcode410 分割数组的最大值

给定一个非负整数数组和一个整数 m，你需要将这个数组分成 m 个非空的连续子数组。设计一个算法使得这 m 个子数组各自和的最大值最小。
输入:
nums = [7,2,5,10,8]
m = 2
输出:
18
解释:
一共有四种方法将nums分割为2个子数组。
其中最好的方式是将其分为[7,2,5] 和 [10,8]，
因为此时这两个子数组各自的和的最大值为18，在所有情况中最小。

【思路】
目标值位于max(nums)和sum(nums)之间，对该区间使用二分查找；
查找条件为：子数组求和<=目标值，可以分割出的最大子集数量（可定义辅助函数表达），要求该数量=m。

class Solution:
    def splitArray(self, nums: List[int], m: int) -> int:
        # 寻找查找目标的辅助函数
        def helper(x):
            res,tmp=0,0
            for num in nums:
                if num+tmp<=x: # 区间和不大于目标值
                    tmp+=num
                else:
                    res+=1
                    tmp=num
            return res+1
        
        i,j=max(nums),sum(nums)
        while i<j:
            mid=(i+j)//2
            if helper(mid)>m:
                i=mid+1
            else:
                j=mid
        return i  # i为满足条件的下界，即为所求最小最大值

【总结】
最大最小值问题，最小最大值问题都可以使用二分查找思想