【LeetCode从零单刷】Search a 2D Matrix I & II

I 题目：

Write an efficient algorithm that searches for a value in an m x n matrix. This matrix has the following properties:

• Integers in each row are sorted from left to right.
• The first integer of each row is greater than the last integer of the previous row.

For example,

Consider the following matrix:

[
  [1,   3,  5,  7],
  [10, 11, 16, 20],
  [23, 30, 34, 50]
]

Given target = 3, return true.

解答：

因为排序过，思路很清晰。建立每行首元素的索引，然后行二分搜索，最后列二分搜索。复杂度是O(lg(m) + lg(n))。但是难点在于细节：

1. 这里的搜索可能 False，也就是找不到元素。因此，如果 first = 1，last = 2，mid = (first + last)/2 = 1。下一次如果 first = mid = 1，又陷入了循环；
2. 因为除法取整的原因，有可能 last 一直无法取到。如果 first = 1，last = 2，mid = (first + last)/2 = 1。下一次如果 first = mid = 1，还是取不到 last = 2 的值。因此需要多判断一次 last 的值；
3. 关于每行首元素的索引中的搜索，不同于列搜索。即使 target > 索引中的最大值，还是有可能存在此元素。例如 target = 30 > 23，依然存在

class Solution {
public:
    bool searchMatrix(vector<vector<int>>& matrix, int target) {
        vector<int> rowfirst;
        for(int i=0; i<matrix.size(); i++)  rowfirst.push_back(matrix[i][0]);
        
        int head = 0;
        int tail = matrix.size() - 1;
        while(head <= tail){
            if(head + 1 == tail || head == tail){
                if(target == rowfirst[head] || target == rowfirst[tail])   return true;
                else    break;
            }
            int mid = (head + tail) / 2;
            if(target > rowfirst[tail])  head = tail;
            else if(target == rowfirst[mid] || target == rowfirst[tail])  return true;
            else if(target < rowfirst[mid])   tail = mid;
            else if(target > rowfirst[mid])   head = mid;
        }
        if(head > tail) return false;
        
        int first = 0;
        int last  = matrix[0].size() - 1;
        while(first <= last){
            if(first == last || first + 1 == last){
                if (matrix[head][first] == target || matrix[head][last] == target)   return true;
                else    return false;
            }
            int mid = (first + last) / 2;
            if(target == matrix[head][mid] || target == matrix[head][last])   return true;
            else if(target < matrix[head][mid])   last = mid;
            else if(target > matrix[head][mid])   first = mid;
        }
        return false;
    }
};

当然，二分搜索还有一种实现方法，就是每次必然移动一位。例如：head = mid +１，tail = mid- 1。

只是这样实现，需要在循环中单独预先判断 head，tail，mid 处的值。具体实现可参见：《Search in Rotated Sorted Array I & II》

II 题目：

Write an efficient algorithm that searches for a value in an m x n matrix. This matrix has the following properties:

• Integers in each row are sorted in ascending from left to right.
• Integers in each column are sorted in ascending from top to bottom.

For example,

Consider the following matrix:

[
  [1,   4,  7, 11, 15],
  [2,   5,  8, 12, 19],
  [3,   6,  9, 16, 22],
  [10, 13, 14, 17, 24],
  [18, 21, 23, 26, 30]
]

Given target = 5, return true.

Given target = 20, return false.

解答：

我的做法比较简单，对每行的首尾遍历范围，行内二分搜索。算法复杂度为 O(m * log n)：

class Solution {
public:
    bool searchMatrix(vector<vector<int>>& matrix, int target) {
        if (matrix.empty() || matrix[0].empty())    return false;
        
        int m = matrix.size();
        int n = matrix[0].size();
        
        int left, right, mid;
        for (int i = 0; i<m; i++) {
            if (matrix[i][0] <= target && target <= matrix[i][n - 1]) {
                left    = 0;
                right   = n - 1;
                while(left <= right) {
                    mid = (left + right) / 2;
                    if (matrix[i][left] == target || matrix[i][right] == target || matrix[i][mid] == target)
                        return true;
                    
                    if (matrix[i][mid] > target)   right = mid - 1;
                    if (matrix[i][mid] < target)   left  = mid + 1;
                }
            }
        }
        return false;
    }
};

但其实还有一种 O(n ^ 1.58) 的复杂度：分治法。

以矩形中点为基准，将矩阵拆分成左上，左下，右上，右下四个区域。若中点值 < 目标值，则舍弃左上区域，从其余三个区域再行查找若中点值 > 目标值，则舍弃右下区域，从其余三个区域再行查找。

具体算法实现与复杂度推导（利用 “主定理 master theorem” 计算复杂度）见：传送门