19.2.19 [LeetCode 81] Search in Rotated Sorted Array II

Suppose an array sorted in ascending order is rotated at some pivot unknown to you beforehand.

(i.e., [0,0,1,2,2,5,6] might become [2,5,6,0,0,1,2]).

You are given a target value to search. If found in the array return true, otherwise return false.

Example 1:

Input: nums = [2,5,6,0,0,1,2], target = 0
Output: true

Example 2:

Input: nums = [2,5,6,0,0,1,2], target = 3
Output: false

Follow up:

• This is a follow up problem to Search in Rotated Sorted Array, where nums may contain duplicates.
• Would this affect the run-time complexity? How and why?

class Solution {
public:
    bool search(vector<int>& nums, int target) {
        if (nums.empty())return false;
        int pivot = nums[0], n = nums.size(), s = 0, e = n - 1;
        while (e>=s && nums[e] == pivot)
            e--;
        if (e < s)return pivot == target;
        while (s <= e) {
            int mid = (s + e) / 2;
            if (nums[mid] >= pivot)
                s = mid + 1;
            else
                e = mid - 1;
        }
        int mididx = e, S, E;
        if (pivot > target)
            S = mididx + 1, E = n - 1;
        else
            S = 0, E = mididx;
        while (S <= E) {
            int mid = (S + E) / 2;
            if (nums[mid] < target)
                S = mid + 1;
            else if (nums[mid] == target)return true;
            else E = mid - 1;
        }
        return false;
    }
};