LeetCode - 解题笔记 - 74 - Search a 2D Matrix

Solution 1

本来以为一个很简单的二分查找，但是没想到确定边界确定的很麻烦。

这道题可以直观地使用两重二分查找进行搜索：

1. 先按行进行二分，要求所寻找的行的行首元素为最大的不大于目标元素的元素
2. 然后在找到的行按列进行二分，寻找目标元素是否存在

但是第一个的要求就让整个二分诡异起来了……首先我们的核心目标不再是找到元素，而是找到一个最大的不大于目标元素的元素。在传统的二分查找上的调整如下：

1. 循环终止于左右指针相等
2. 中点位置向上取整（尽量找上界）
3. 小于等于的情况，从当前中点开始，舍弃左区间（当前行有效）

折腾死我了……其实可以把整个矩阵展开成一维矩阵进行精确二分查找，效率相同，就不写了

• 时间复杂度：$O(\log m+\log n)$，其中$m$和$n$分别为矩阵的行数和列数，两轮二分查找
• 空间复杂度：$O(1)$，仅维护常数个状态量

class Solution {
public:
    bool searchMatrix(vector<vector<int>>& matrix, int target) {
        int m = matrix.size(), n = matrix[0].size();

        // 行之间的二分
        int leftRow = 0, rightRow = m - 1;
        while (leftRow < rightRow) {
            int middleRow = leftRow + (rightRow - leftRow + 1) / 2; // 中值向上取整
            // 行首元素应当不大于target
            if (matrix[middleRow][0] <= target) {
                leftRow = middleRow;
            } else {
                rightRow = middleRow - 1;
            }
        }
        
        int row = leftRow;
        
        if (matrix[row][0] > target) {
            return false;
        } else if (matrix[row][0] == target) {
            return true;
        } else {
            // 行内二分
            int leftCol = 0, rightCol = n - 1;
            while (leftCol <= rightCol) {
                int middleCol = leftCol + (rightCol - leftCol) / 2;
                if (matrix[row][middleCol] < target) {
                    leftCol = middleCol + 1;
                } else if (matrix[row][middleCol] > target) {
                    rightCol = middleCol - 1;
                } else {
                    return true;
                }
            }
        }
        
        return false;
    }
};

Solution 2

这里参考了下面这个连接提供的思路：（效果可能不太好，但是更加直观）

力扣

将整个数组看整一个BST，以右上角节点为根节点，左侧为左子树（小于），下方为右子树（大于），只需要在整个BST上进行搜索，可以在线性时间复杂度实现查找过程。

• 时间复杂度：$O(m+n)$，其中$m$和$n$分别为矩阵的行数和列数，BST的计算搜索步骤就是向左和向下移动整个长度
• 空间复杂度：$O(1)$，仅维护常数个状态量

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

Solution 3

Solution 1的Python实现。

class Solution:
    def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:
        m, n = len(matrix), len(matrix[0])
        
        leftRow, rightRow = 0, m - 1
        while leftRow < rightRow:
            middleRow = leftRow + (rightRow - leftRow + 1) // 2
            if matrix[middleRow][0] <= target: leftRow = middleRow
            else: rightRow = middleRow - 1
                
        row = leftRow
        
        if matrix[row][0] > target: return False
        elif matrix[row][0] == target: return True
        else:
            leftCol, rightCol = 0, n - 1
            while leftCol <= rightCol:
                middleCol = leftCol + (rightCol - leftCol) // 2
                if matrix[row][middleCol] < target: leftCol = middleCol + 1
                elif matrix[row][middleCol] > target: rightCol = middleCol - 1
                else: return True
                
        return False

Solution 4

Solution 2的Python实现。

class Solution:
    def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:
        m, n = len(matrix), len(matrix[0])

        i, j = 0, n - 1
        while i < m and j >= 0:
            if matrix[i][j] == target: return True
            elif matrix[i][j] > target: j -= 1
            else: i += 1
                
        return False