【二分查找】leetcode 240. 搜索二维矩阵 II

240. 搜索二维矩阵 II

题目描述

编写一个高效的算法来搜索 m x n 矩阵 matrix 中的一个目标值 target 。该矩阵具有以下特性：

• 每行的元素从左到右升序排列。
• 每列的元素从上到下升序排列。

示例1：

输入： 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

示例2：

输入： 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 = 20
输出： false

提示

• $m==matrix.length$
• $n==matrix[i].length$
• $1<=n,m<=300$
• $-10^9<=matrix[i][j]<=10^9$
• $每行的所有元素从左到右升序排列$
• $每列的所有元素从上到下升序排列$
• $-10^9<=target<=10^9$

方法一：暴力解法

解题思路

遍历每一行中的每一个元素，判断是否为目标值。

在这里我遇到一个问题：
为什么遍历矩阵的每一行时，在前面加上了 const auto& 就时间效率变高了？而不加却超时了？

1. for(auto x: arr)，这样子只会拷贝一份 arr 中的元素，在循环体中无论怎么修改拷贝的元素的值，是不会影响到原有集合中的元素的值的。
2. for(auto &x: arr)，这样子相当于获取一份 arr 中的元素的引用，如果修改元素的值，那么原有集合中的元素的值也相应改变。
3. for(const auto &x: arr)，这样子也会获取一份 arr 中的元素的引用，但只可以读取元素的值，不可以修改元素的值，效率会比用 auto 更快一些。

代码

class Solution {
public:
    bool searchMatrix(vector<vector<int>>& matrix, int target) {
        for(const auto &x: matrix)
            for(int y: x)
                if(y == target)
                    return true;
        return false;
    }
};
1
2
3
4
5
6
7
8
9
10

复杂度分析

• 时间复杂度：$O(nm)$。
• 空间复杂度：$O(1)$。

方法二：二分查找

解题思路

遍历矩阵的每一行，对每一行进行二分查找，比一个个查找要快一些。

代码

class Solution {
public:
    bool searchMatrix(vector<vector<int>>& matrix, int target) {
        for(const auto &x: matrix) {
            int l = 0, r = x.size() - 1, mid;
            while(l <= r) {
                mid = (l + r) >> 1;
                if(x[mid] == target)
                    break;
                else if(x[mid] < target)
                    l = mid + 1;
                else
                    r = mid - 1;
            }
            if(l <= r)
                return true;
        }
        return false;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

复杂度分析

• 时间复杂度：$O(mlogn)$。每一次二分查找的时间复杂度为 $O(logn)$，最多需要 $m$ 次二分查找。
• 空间复杂度：$O(1)$。

方法三：Z 字形查找

解题思路

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

• 如果 $target>matrix[i][j]$，因为矩阵的每一行元素都是按升序排列的，那么在当前的搜索矩阵中，这一行元素都是小于 $target$ 的，因此可以将它们忽略，即将 $x$ 增加 1。
• 如果 $target<matrix[i][j]$，因为矩阵的每一列元素都是按升序排列的，那么在当前的搜索矩阵中，这一列元素都是大于 $target$ 的，因此可以将它们忽略，即将 $y$ 减少 1。
• 如果 $target=matrix[i][j]$，则说明找到目标值。

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

代码

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

复杂度分析

• 时间复杂度：$O(m+n)$。由于 $(x,y)$ 的初始值分别为 $(0,n-1)$，因此 $y$ 最多能被减少 $n$ 次，$x$ 最多能被增加 $m$ 次，总搜索次数为 $m+n$。
• 空间复杂度：$O(1)$。