LeetCode01_二分法专题_与mid,mid+1

一.二分法基本思想

• 二分法做题流程(重要)：
  • 1.确定二分的边界
  • 2.编写二分的代码框架
  • 3.设计一个check(性质)
  • 4.判断一下区间如何更新
  • 5.如果更新方式写的是l = mid, r = mid - 1，那么就在计算mid的时候加上1

二.二分法典型习题

1.LeetCode-69 求解Sqrt(x)

• 解题思路：因为求的是sqrt(x)，则x的取值范围是[0, x]，因此在此区间中的所有点t均符合性质：t^2 <= x即t <= sqrt(x)
  。因此，寻找的是分界点2，采用模板2。

  class Solution {
  public:
      int mySqrt(int x) {
          int l=0, r = x;
          while(l < r){
              int mid = l + (long long)r + 1 >> 1;
              if (mid <= x / mid) l = mid;  // mid * mid <= x;这样写法不好，会出现乘法溢出
              else r = mid - 1;
          }
          return r;
      }
  };
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12

2.LeetCode-35 搜索插入位置

• 解题思路：找到大于等于插入元素x的第一个位置，即t >= x，符合模板1

  class Solution {
  public:
      int searchInsert(vector<int>& nums, int target) {
          if(nums.empty() || nums.back() < target) return nums.size();  // nums.back() < target:插入的数字比当前数组中所有元素都大，直接返回数组的长度
          
          int l = 0, r = nums.size() - 1;
          while(l < r){
              int mid = l + r >> 1;
              if(nums[mid] >= target) r = mid;
              else l = mid + 1;
          }
          return r;
      }
  };
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14

3.LeetCode-34 在排序数组中查找元素的第一个和最后一个位置

• 解题思路：使用两次二分算法!确定起始位置：使用性质x >= target来划分整个区间；确定终止位置：使用性质x <= target来划分整个区间。

  class Solution {
  public:
      vector<int> searchRange(vector<int>& nums, int target) {
          if(nums.empty()) return {-1,-1};
          // 确定起始位置
          int l = 0, r = nums.size() - 1;
          while(l < r){
              int mid = l + r >> 1;
              if(nums[mid] >= target) r = mid;
              else l = mid + 1;
          }
          
          if(nums[r] != target) return {-1,-1};  // 二分出来的起始位置不等于target，则数组中不存在target这个数
          int start = r;
          // 确定终止位置
          l = 0, r = nums.size() -1 ;
          while(l < r){
              int mid = l + r + 1 >> 1;
              if(nums[mid] <= target) l = mid;
              else r = mid - 1;
          }
          int end = r;
          return {start, end};
      }
  };
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22
  23
  24
  25

4.LeetCode-74 搜索二维矩阵

• 解题思路：给二维矩阵的每个元素进行编号,从0到n*m-1为止，根据题目中的规定，可以将二维矩阵看成是一个严格单调递增的一维数组。选择划分区间的性质x >= target。关键是如何将二维矩阵转换成一维数组，转换公式是j矩阵元素a_ij对应的行下标i=[k/m],列下标j=k%m;其中k是一维数组中的下标。

  class Solution {
  public:
      bool searchMatrix(vector<vector<int>>& matrix, int target) {
          if(matrix.empty() || matrix[0].empty()) return false;
          
          int n = matrix.size(), m = matrix[0].size();
          int l = 0, r = n * m - 1;
          while(l < r){
              int mid = l + r >> 1;
              if(matrix[mid / m][mid % m] >= target) r = mid;
              else l = mid + 1;
          }
          
          if(matrix[r / m][r % m] != target) return false;
          return true;
      }
  };
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17

5.LeetCode-153 寻找旋转排序数组中的最小值

• 解题思路：利用性质target <= nums.back()，可以将区间划分成两段，前一段中所有的元素都大于nums.back(),后一段中所有的元素都符合上面这个性质。

  class Solution {
  public:
      int findMin(vector<int>& nums) {
          int l = 0, r = nums.size();
          while(l < r){
              int mid = l + r >> 1;
              if(nums[mid] <= nums.back()) r = mid;
              else l = mid + 1;
          }
          return nums[r];
      }
  };
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12

6.LeetCode-33 搜索旋转排序数组

• 解题思路：根据上一题的思路，先利用性质target <= nums.back()确定给定的目标值存在于左边区间还是右边区间。接着利用二分法返回目标值所对应的下标。

  class Solution {
  public:
      int search(vector<int>& nums, int target) {
          if(nums.empty()) return -1;
          int l = 0, r = nums.size() - 1;
          // 首先找到区间中的最小值，将整个区间划分成左右两段
          while(l < r){
              int mid = l + r >> 1;
              if(nums[mid] <= nums.back()) r = mid;
              else l = mid + 1;
          }
          
          if(target <= nums.back()) r = nums.size() - 1;   // target在后一段区间中
          // 否则target在前一段区间中
          else l = 0, r--;
          
          while(l < r){
              int mid  = l + r >> 1;
              if(nums[mid] >= target) r = mid;
              else l = mid + 1;
          }
          
          if(nums[l] == target) return l;
          return -1;
      }
  };
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22
  23
  24
  25
  26

7.LeetCode-278 第一个错误的版本

• 解题思路：找到第一个错误的版本，则后面的错误版本号一定是大于第一个个错误的版本号，因此性质取的是nums[mid] >= target。

  // Forward declaration of isBadVersion API.
  bool isBadVersion(int version);
  
  class Solution {
  public:
      int firstBadVersion(int n) {
          int l = 1, r = n;
          while(l < r){
              int mid = (long long)l + r >> 1;  // long long防止溢出
              if(isBadVersion(mid)) r = mid;
              else l = mid + 1;
          }
          return r;
      }
  };
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15

8.LeetCode-162 寻找峰值

• 解题思路：属于其他5%的情况，不具有区间的二段性性质。最快的方法时间复杂度是O(logn)。经过分析可知，答案一定在区间当中的。然后，计算区间的中点mid,然后判断mid与mid+1之间的关系，如果nums[mid] < nums[mid+1],则区间[mid+1,r]中一定存在一个答案。反之果nums[mid] > nums[mid+1]，同理。

  class Solution {
  public:
      int findPeakElement(vector<int>& nums) {
          int l = 0, r = nums.size() - 1;
          while(l < r){
              int mid = l + r >> 1;
              if(nums[mid] > nums[mid + 1]) r = mid;
              else l = mid + 1;
          }
          return r;
      }
  };
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12

9.LeetCode-287 寻找重复数

• 解题思路：根据抽屉原理+二分法即可，分别统计[l,mid]和[mid,r]中实际的元素个数(苹果个数)，然后因为[l,mid]中一共可以存放的元素个数是mid-l+1(抽屉个数)；[mid,r]中一共可以存放的元素个数是r-mid。比较苹果个数和抽屉个数的大小，可以确定重复元素在哪个区间中，每次可以将区间缩小为原来的一半。

  class Solution {
  public:
      int findDuplicate(vector<int>& nums) {
          // 抽屉原理 + 二分法可以解决
          int l = 1, r = nums.size() - 1;
          while(l < r){
              int mid = l + r >> 1;
              int cnt = 0;
              for(auto x: nums)
                  if(x >= l && x <= mid)
                      cnt++;  // 苹果个数cnt
              if(cnt > mid - l + 1) r = mid;  // 左半边区间中抽屉个数mid - l + 1
              else l = mid + 1;
          }
          return r;
      }
  };
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17

10.LeetCode-275 H指数 II

• 解题思路：找到一个最大的数h，使得数组中至少存在h个数都大于等于h。首先确定边界，h一定是小于等于n(因为当h大于n时假设为n+1，则是找不到最大的数n+1，使得数组中至少存在n+1个数都大于等于n+1)，h一定是大于等于0。划分区间性质是：找到一个最大的数h-1，使得数组中至少存在h-1个数都大于等于h-1，即[0,h]条件成立，[h+1,n]条件不成立，n表示元素总数。

  class Solution {
  public:
      int hIndex(vector<int>& nums) {
          int l = 0, r = nums.size();
          while(l < r){
              int mid = l + r + 1 >> 1;
              if(nums[nums.size() - mid] >= mid) l = mid;
              else r = mid - 1;
          }
          return l;
      }
  };
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12