PigyChan_LeetCode 74. 搜索二维矩阵

74. 搜索二维矩阵

难度中等

编写一个高效的算法来判断 m x n 矩阵中，是否存在一个目标值。该矩阵具有如下特性：

（1）每行中的整数从左到右按升序排列。
（2）每行的第一个整数大于前一行的最后一个整数。

示例 1：

输入：matrix = [[1,3,5,7],[10,11,16,20],[23,30,34,50]], target = 3
输出：true
示例 2：

输入：matrix = [[1,3,5,7],[10,11,16,20],[23,30,34,50]], target = 13
输出：false
示例 3：

输入：matrix = [], target = 0
输出：false

提示：

（1）m == matrix.length
（2）n == matrix[i].length
（3）0 <= m, n <= 100
（4）-104 <= matrix[i][j], target <= 104

个人思路1.0：

（1）先用二分查找法找到对应行
1）target>col[n]，向下搜索
2）target<col[0]，向上搜索
（2）再用二分查找找到是否有对应函数

代码1.0：

  class Solution {
  public:
      bool searchMatrix(vector<vector<int>>& matrix, int target) {
          if (matrix.empty()) return false;
          int row = matrix.size();
          int col = matrix[0].size();
          
          int left = 0;
          int right = row - 1;
          int find_row;
          while (left < right - 1) {
              int mid = left + (right - left) / 2;
              //向上
              if (matrix[mid][0] > target) {
                  right = mid;
              }
              //向下
              else if (matrix[mid][col - 1] < target) {
                  left = mid;
              }
              //找到对应行
              else if (matrix[mid][0]<=target && matrix[mid][col - 1]>=target) {
                  find_row = mid;
                  break;
              }
          }
          if (left == right - 1) {
              if (matrix[left][0]<=target && matrix[left][col - 1]>=target)
                  find_row = left;
              else if (matrix[right][0]<=target && matrix[right][col - 1]>=target)
                  find_row = right;
          }
          if (find(matrix[find_row].begin(), matrix[find_row].end(), target) !=  matrix[find_row].end())
              return true;
          
          return false;
      }
  };

好久没写二分查找，感觉代码好丑陋，去题解逛逛改进一下

代码2.0：

  class Solution {
  public:
      bool searchMatrix(vector<vector<int>>& matrix, int target) {
          int row = matrix.size();
          if(row == 0) return false;
          int col = matrix[0].size();
          if(col==0) return false;
          
          int left = 0;
          int right = row - 1;
          while (left <= right) {
              int mid = (left + right) / 2;


              if (matrix[mid][0] > target) right = mid - 1;
              else if (matrix[mid][col - 1] < target) left = mid + 1;
              else if (matrix[mid][0]<=target && matrix[mid][col - 1]>=target) {
                  if (find(matrix[mid].begin(), matrix[mid].end(), target) != matrix[mid].end())
                      return true;
                  else
                      return false;
              }
          }


          return false;
      }
  };

代码变好看了怎么内存消耗增大了。。

代码3.0：

class Solution {
  public:
      bool searchMatrix(vector<vector<int>>& matrix, int target) {
          int row = matrix.size();
          if (row == 0) return false;
          int col = matrix[0].size();
          if (col == 0) return false;
          
          int left = 0;
          int right = row - 1;
          while (left <= right) {
              int mid = (left + right) / 2;


              if (matrix[mid][0] > target) right = mid - 1;
              else if (matrix[mid][col - 1] < target) left = mid + 1;
              else if (matrix[mid][0]<=target && matrix[mid][col - 1]>=target) {
                  left = 0;
                  right = col - 1;
                  while (left <= right) {
                      int newMid = (left + right) / 2;
                      int findVal = matrix[mid][newMid];


                      if (findVal > target) right = newMid - 1;
                      else if (findVal < target) left = newMid + 1;
                      else if (findVal == target) return true;
                  }
                  return false;
              }
          }


          return false;
      }
  };

用二分法代替了泛型算法find()，提高了一丢丢内存，感觉是迭代器造成的影响。