早起做LeetCode——剑指 Offer 11. 旋转数组的最小数字

做题链接：https://leetcode-cn.com/problems/xuan-zhuan-shu-zu-de-zui-xiao-shu-zi-lcof/

二分法 + 反向去重法
提交结果：耗时4ms，内存11.8M
由于在去重的地方优化了下，耗时是官方解答的一半

当遇到相同元素时，由于不确定遍历左边还是右边，这里采用的方法是，先从mid开始往前遍历到low，找到第一个不等于mid处值的元素a，

如果a<mid处值，则最小值肯定在[low，a]之间；

如果a>mid处值，则说明[low, mid]之间都是重复值，则最小值在[mid，high]之间。

由于此处需要一一遍历，重在找到第一个不等于mid的值，因此此处去重的部分不能采用二分法等查找方法

#include <bits/stdc++.h>
#include <sys/time.h>
using namespace std;

class Solution {
public:
    int minArray(vector<int>& numbers) {
        int cur_min = numbers[0];
        int low = 1;
        int high = numbers.size() - 1;
        int flag = 0;
        while(low <= high){
            int mid = (low + high) / 2;
            if(numbers[mid] < cur_min){
                cur_min = numbers[mid];
                high = mid - 1;
            }else if(numbers[mid] > cur_min){
                low = mid + 1;
            }else{
                flag = 0;
                for(int i = mid - 1; i >= low; i--){
                    if(numbers[i] < cur_min){
                        high = mid - 1;
                        flag = 1;
                        break;
                    }
                    if(numbers[i] > cur_min) break;
                }
                if(flag == 0) low = mid + 1;
            }
        }
        return cur_min;
    }
};

int main(){
//	vector<int> s = {2, 2, 2, 0, 1}; // 0
//	vector<int> s = {1, 2, 0, 1, 1, 1};  // 0
//	vector<int> s = {3,4,5,1,2};  //1
//	vector<int> s = {3,3,3,4,4,4,5,6,6,1,1,1,1,2,2,2,2}; //1
	vector<int> s = {1,3,5};  //1
	Solution sol;
	int res = sol.minArray(s);
	cout<<res<<endl;
	return 0;
}