LeetCode【每日一题】 1095. 山脉数组中查找目标值

题目

1095. 山脉数组中查找目标值

（这是一个 交互式问题 ）

给你一个 山脉数组 mountainArr，请你返回能够使得 mountainArr.get(index) 等于 target 最小 的下标 index 值。
如果不存在这样的下标 index，就请返回 -1。

何为山脉数组？如果数组 A 是一个山脉数组的话，那它满足如下条件：
首先，A.length >= 3
其次，在 0 < i < A.length - 1 条件下，存在 i 使得：

A[0] < A[1] < ... A[i-1] < A[i]
A[i] > A[i+1] > ... > A[A.length - 1]

你将 不能直接访问该山脉数组，必须通过 MountainArray 接口来获取数据：

MountainArray.get(k) - 会返回数组中索引为k 的元素（下标从 0 开始）
MountainArray.length() - 会返回该数组的长度

注意：

对 MountainArray.get 发起超过 100 次调用的提交将被视为错误答案。此外，任何试图规避判题系统的解决方案都将会导致比赛资格被取消。

为了帮助大家更好地理解交互式问题，我们准备了一个样例 “答案”：https://leetcode-cn.com/playground/RKhe3ave
，请注意这 不是一个正确答案。

示例 1：

输入：array = [1,2,3,4,5,3,1], target = 3
输出：2
解释：3 在数组中出现了两次，下标分别为 2 和 5，我们返回最小的下标 2。

示例 2：

输入：array = [0,1,2,4,2,1], target = 3
输出：-1
解释：3 在数组中没有出现，返回 -1。

提示：

3 <= mountain_arr.length() <= 10000
0 <= target <= 10^9
0 <= mountain_arr.get(index) <= 10^9

来源：力扣（LeetCode）

二分查找

题目要求我们对get方法的调用不超过100次，本题的数据规模最大为10000，由此我们可以知道本题的算法要求的时间复杂度为logN。
首先先讲解一下二分查找的两种思路

int nums[n]; //需要查找的数组(有序)
int target = a //需要查找的值
int l = 0, r = n - 1;

// 第一种
while(l <= r){
	int mid = (l + r) / 2;
	if(nums[mid] == target) return mid; //返回下标
 	if(nums[mid] > target) r = mid - 1;
 	else l = mid + 1;
}

// 第二种
while(l < r){
	int mid = (l + r) / 2;
	if(nums[mid] < target) l = mid + 1;
	else r = mid
}
if(nums[l] == target) return l;

第一种思路在退出循环以后有 l = r + 1，并且需要在循环体内判断是否查找到目标元素，循环体有三个分支
第二种思路在退出循环后有 l == r，循环体内只有两个分支，在循环体外部判断下标 l 或者 r 对应的元素是否是目标元素
第二种思路的好处是退出循环后一定有 l == r，我们不需要去考虑返回哪一个下标，但对应的也有一个需要特别注意的地方，就是第二种思路的另一种写法

while(l < r){
	int mid = (l + r) / 2;
	if(nums[mid] > target) r = mid - 1;
	else l = mid
}
if(nums[l] == target) return l;

我们思考一种情况，nums = {1,2}，target = 2，循环体在执行时首先计算mid = （l + r）/ 2，mid = 0，接下来由于nums[0] < target，程序进入到第二条分支，l = mid，这时我们发现搜索的区间并没有减小，程序将进入死循环。所以在程序中出现 l = mid 这条分支的时候，我们修改mid的取整方式，改为向上取整

mid = (l + r + 1) / 2 //向上取整

对于本题，我们选择使用第二种思路，题目说明山脉数组中的山顶元素唯一，所以我们可以先求出山顶元素，根据山顶元素将山脉数组划分成两个有序的数组，分别进行二分查找。

代码：

/**
 * // This is the MountainArray's API interface.
 * // You should not implement it, or speculate about its implementation
 * class MountainArray {
 *   public:
 *     int get(int index);
 *     int length();
 * };
 */

class Solution {
	// 查找山顶元素
    int findMountainTop(int left, int right, MountainArray& mountainArr, int target){
        while(left < right){
            int mid = left + (right - left + 1) / 2;
            if(mountainArr.get(mid) > mountainArr.get(mid + 1))
                //下一轮搜索的区间 [left, mid - 1];
                right = mid - 1;
            else
                //下一轮搜索的区间 [mid, right]
                left = mid;
        }
        return left;
    }
	// 在升序数组中查找目标元素
    int findSortedArray(int left, int right, MountainArray& mountainArr, int target){
        while(left < right){
            int mid = left + (right - left + 1) / 2;
            if(mountainArr.get(mid) > target)
                //下一轮搜索的区间 [left, mid - 1]
                right = mid - 1;
            else 
                //下一轮搜索的区间 [mid, right]
                left = mid;
        }
        if(mountainArr.get(left) == target) return left;
        return -1;
    }
	// 在降序数组中查找目标元素
    int findReverseArray(int left, int right, MountainArray& mountainArr, int target){
        while(left < right){
            int mid = left + (right - left) / 2;
            if(mountainArr.get(mid) > target)
                //下一轮搜索的区间 [mid + 1, right]
                left = mid + 1;
            else
                //下一轮搜索的区间 [left, mid]
                right = mid;
        }
        if(mountainArr.get(left) == target) return left;
        return -1;
    }
public:
    int findInMountainArray(int target, MountainArray &mountainArr) {
        
        int left = 0, right = mountainArr.length() - 1;
        //查找山顶元素
        int top = findMountainTop(left, right, mountainArr, target);
        if(mountainArr.get(top) == target) return top;

        //由于题目要求最小的下标值，所以我们先在递增部分中查找
        int res = findSortedArray(left, top - 1, mountainArr, target);
        if(res != -1) return res;

        //在递减部分中查找
        return findReverseArray(top + 1, right, mountainArr, target);
    }
};