81_搜索旋转排序数组 II

'''
81_搜索旋转排序数组 II
假设按照升序排序的数组在预先未知的某个点上进行了旋转。
( 例如，数组 [0,0,1,2,2,5,6] 可能变为 [2,5,6,0,0,1,2] )。
编写一个函数来判断给定的目标值是否存在于数组中。若存在返回 true，否则返回 false。
示例 1:
输入: nums = [2,5,6,0,0,1,2], target = 0
输出: true
示例 2:
输入: nums = [2,5,6,0,0,1,2], target = 3
输出: false
进阶:
这是 搜索旋转排序数组 的延伸题目，本题中的 nums  可能包含重复元素。
这会影响到程序的时间复杂度吗？会有怎样的影响，为什么？
'''
class Solution:
    '''
    算法1：先找到右侧第一个最小值，再对分查找target
    执行用时 :132ms, 在所有 python3 提交中击败了7.49%的用户
    内存消耗 :29.2 MB, 在所有 python3 提交中击败了5.61%的用户
    '''
    def search(self, nums:list, target: int) -> int:
        import bisect
        L, R = 0, len(nums)-1
        while L < R:
            m = (L + R) // 2
            if nums[L] == nums[m] == nums[R]:
                L += 1 #或R -= 1
            elif nums[m] <= nums[R]:
                R = m
            else:
                L = m + 1
        while L > 0 and nums[L] == nums[L-1]:#确保L指向右侧第一个最小值
            L -= 1
        if L > 0 and target > nums[-1]: #左侧寻找
            p = bisect.bisect_left(nums, target, 0, L) 
        else:#右侧寻找
            p = bisect.bisect_left(nums, target, L, len(nums))
        return p < len(nums) and nums[p] == target
    
    '''
    算法2：当nums[L] == nums[m] == nums[R]时，采用顺序查找方法，逐步缩小左边界（或者右边界），以便下一轮循环时，不再出现此种情况。
    排除特殊情况后，直接分区间查找。m将数组分成两部分，总有一侧是纯递增数组（也可能两边都是纯递增），
    若nums[m] >= nums[L],则[L:m]是一个递增区间，否则[m:R]是一个递增区间。
    我们可以先判断target是否处于纯递增区间，再来更新边界值
    执行用时 :116ms, 在所有 python3 提交中击败了6.20%的用户
    内存消耗 :29.2 MB, 在所有 python3 提交中击败了5.61%的用户
    '''
    def search2(self, nums:list, target: int) -> int:
        L, R = 0, len(nums)-1
        while L <= R:
            m = (L + R) // 2
            if nums[m] == target:
                return True
            elif nums[L] == nums[m] == nums[R]:#特殊情况逐步减少搜索范围
                L += 1 #或R -= 1
            elif nums[m] >= nums[L]:#[L:m]是一个递增区间
                if nums[L] <= target < nums[m]:#target介于单调递增的[L:m]区间
                    R = m - 1
                else:
                    L = m + 1
            else:  #[m:R]是一个递增区间
                if nums[m] < target <= nums[R]:#target介于单调递增的[m:R]区间
                    L = m + 1
                else:
                    R = m - 1
        return False
    
    '''
    算法3：对算法2的一个改进，先快速去重，再分区间查找
    执行用时 :124ms, 在所有 python3 提交中击败了6.20%的用户
    内存消耗 :29.2 MB, 在所有 python3 提交中击败了5.61%的用户
    '''
    def search3(self, nums:list, target: int) -> int:
        L, R = 0, len(nums)-1
        while L <= R:
            while L < R and nums[L] == nums[R]:#快速去重
                L += 1
            m = (L + R) // 2
            if nums[m] == target:
                return True
            elif nums[m] >= nums[L]:#[L:m]是一个递增区间
                if nums[L] <= target < nums[m]:#target介于单调递增的[L:m]区间
                    R = m - 1
                else:
                    L = m + 1
            else:  #[m:R]是一个递增区间
                if nums[m] < target <= nums[R]:#target介于单调递增的[m:R]区间
                    L = m + 1
                else:
                    R = m - 1
        return False
    


    
x = Solution()
a = [1,1,1,1,1,1,2,1,1,1]
a = []
for i in range(-2, 3):
    print(i, x.search(a, i), x.search2(a, i), x.search3(a, i))