剑指 Offer 04. 二维数组中的查找（LeetCode 240. 搜索二维矩阵 II）

题目：

链接：剑指 Offer 04. 二维数组中的查找；LeetCode 240. 搜索二维矩阵 II
难度：中等

在一个 n * m 的二维数组中，每一行都按照从左到右 非递减 的顺序排序，每一列都按照从上到下 非递减 的顺序排序。请完成一个高效的函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。

示例:

现有矩阵 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]
]
给定 target = 5，返回 true。
给定 target = 20，返回 false。

限制：

0 <= n <= 1000
0 <= m <= 1000

方法一：

解题思路：

二分查找法。对于每一行或列都是升序排列的，所以可以用二分查找优化时间复杂度。

代码一：

class Solution {
public:
    bool findNumberIn2DArray(vector<vector<int>>& matrix, int target) {  //二分查找
        for(int i = 0; i < matrix.size(); i++)
        {
            int l = 0, r = matrix[i].size() - 1;
            while(r - l >= 0) {
                int mid = (l + r) / 2;
                if(matrix[i][mid] > target) r = mid - 1;
                else if(matrix[i][mid] < target) l = mid + 1;
                else return true;
            }
        }
        return false;
    }
};

时间复杂度O(n*log(m))，空间复杂度O(1)。

※方法二：

解题思路：

我们可以从矩阵 matrix 的右上角 (0, n-1)(0,n−1) 进行搜索。在每一步的搜索过程中，如果我们位于位置 (x, y)，那么我们希望在以 matrix 的左下角为左下角、以 (x, y) 为右上角的矩阵中进行搜索，即行的范围为 [x, m - 1]，列的范围为 [0, y]：

• 如果 matrix[x, y] = target，说明搜索完成；
• 如果 matrix[x, y] > target，由于每一列的元素都是升序排列的，那么在当前的搜索矩阵中，所有位于第 y 列的元素都是严格大于 target 的，因此我们可以将它们全部忽略，即将 y 减少 1；
• 如果 matrix[x, y] < target，由于每一行的元素都是升序排列的，那么在当前的搜索矩阵中，所有位于第 x 行的元素都是严格小于 target 的，因此我们可以将它们全部忽略，即将 x 增加 1。

在搜索的过程中，如果我们超出了矩阵的边界，那么说明矩阵中不存在 target。

※代码二：

class Solution {
public:
    bool findNumberIn2DArray(vector<vector<int>>& matrix, int target) {
        if(matrix.size() == 0) return false;
        int i = 0, j = matrix[0].size() - 1;
        while(i < matrix.size() && j >= 0) {
            if(matrix[i][j] == target) return true;
            else if(matrix[i][j] > target) j--;
            else i++;
        }
        return false;
    }
};

时间复杂度O(n+m)，空间复杂度O(1)。

方法三：

解题思路：

递归切割搜索方阵，方阵中按对角线层序遍历。

每次切割出当前矩阵中最大的方阵，搜索方阵，然后在切割后的剩余矩阵中再切割最大方阵并搜索，以此类推……
方阵中的搜索方法：因为该矩阵中每个元素一定大于其正上和正左的所有元素，故想到按对角线层序遍历（图中红色箭头为分层），以对角线元素初步判断target可能所在的层（若对角线元素 （其实这里还可以优化一下，层内搜索时使用二分法查找）

代码三：

class Solution {
public:
    bool searchM(vector<vector<int>>& matrix, int target, int begin_m, int begin_n, int length_m, int length_n){ //递归切割搜索方阵
        //先切割出最大的方阵进行搜索
        int length_square = min(length_m,length_n); //方阵的宽高
        for(int i = 0 ; i < length_square ; i++) //顺序搜索方阵的对角线元素（因为每个元素一定大于它左上的所有元素，相当于层次搜索）
        {
            if(matrix[begin_m+i][begin_n+i] >= target) { //确定target可能所在的层，然后搜索该层所有元素
                for(int j = 0 ; j <= i ; j++)
                {
                    if(matrix[begin_m+i][begin_n+j] == target || matrix[begin_m+j][begin_n+i] == target) return true;
                }
            }
        }
        //然后搜索切割剩下的矩阵(该剩余矩阵只可能在方阵的正下方或正右方)
        if(begin_m + length_square < matrix.size()){ //切割后剩余矩阵在方阵下方时
            return searchM(matrix, target, begin_m+length_square, begin_n, length_m-length_square, length_n);
        }
        else if(begin_n + length_square < matrix[0].size()){ //切割后剩余矩阵在方阵右方时
            return searchM(matrix, target, begin_m, begin_n+length_square, length_m, length_n-length_square);
        }
        //未找到target
        return false;
    }
    bool searchMatrix(vector<vector<int>>& matrix, int target) {
        return searchM(matrix, target, 0, 0, matrix.size(), matrix[0].size());
    }
};

时间复杂度O(max(m,n)*log(min(m,n))，空间复杂度O(1)。
（联想递归执行过程，搜索对角线总共用时max(m,n)，方阵每层搜索用时最多log(min(m,n))。）

方法四：

解题思路：

实测暴力查找也能通过。

代码四：

class Solution {
public:
    bool findNumberIn2DArray(vector<vector<int>>& matrix, int target) {  //暴力一下试试能不能过
        for(int i = 0; i < matrix.size(); i++)
        {
            for(int j = 0; j < matrix[0].size(); j++)
            {
                if(matrix[i][j] == target) return true;
            }
        }
        return false;
    }
};

时间复杂度O(nm)，空间复杂度O(1)。