题目描述
编写一个高效的算法来搜索 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 = = m a t r i x . l e n g t h m == matrix.length m==matrix.length
- n = = m a t r i x [ i ] . l e n g t h n == matrix[i].length n==matrix[i].length
- 1 < = n , m < = 300 1 <= n, m <= 300 1<=n,m<=300
- − 1 0 9 < = m a t r i x [ i ] [ j ] < = 1 0 9 -10^9 <= matrix[i][j] <= 10^9 −109<=matrix[i][j]<=109
- 每行的所有元素从左到右升序排列 每行的所有元素从左到右升序排列 每行的所有元素从左到右升序排列
- 每列的所有元素从上到下升序排列 每列的所有元素从上到下升序排列 每列的所有元素从上到下升序排列
- − 1 0 9 < = t a r g e t < = 1 0 9 -10^9 <= target <= 10^9 −109<=target<=109
方法一:暴力解法
解题思路
遍历每一行中的每一个元素,判断是否为目标值。
在这里我遇到一个问题:
为什么遍历矩阵的每一行时,在前面加上了 const auto& 就时间效率变高了?而不加却超时了?
- for(auto x: arr),这样子只会拷贝一份 arr 中的元素,在循环体中无论怎么修改拷贝的元素的值,是不会影响到原有集合中的元素的值的。
- for(auto &x: arr),这样子相当于获取一份 arr 中的元素的引用,如果修改元素的值,那么原有集合中的元素的值也相应改变。
- 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;
}
};
复杂度分析
- 时间复杂度: O ( n m ) O(nm) O(nm)。
- 空间复杂度: O ( 1 ) O(1) 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;
}
};
复杂度分析
- 时间复杂度: O ( m l o g n ) O(mlogn) O(mlogn)。每一次二分查找的时间复杂度为 O ( l o g n ) O(logn) O(logn),最多需要 m m m 次二分查找。
- 空间复杂度: O ( 1 ) O(1) O(1)。
方法三:Z 字形查找
解题思路
我们可以从矩阵 m a t r i x matrix matrix 的右上角 ( 0 , n − 1 ) (0,n-1) (0,n−1) 位置处开始搜索。在每一步的搜索过程中,如果此时位于位置 ( x , y ) (x,y) (x,y),那么我们希望在以 m a t r i x matrix matrix 的左下角为左下角,以 ( x , y ) (x,y) (x,y) 为右上角的矩阵中进行搜索,即行的范围为 [ x , m − 1 ] [x,m-1] [x,m−1],列的范围为 [ 0 , y ] [0,y] [0,y]。
- 如果 t a r g e t > m a t r i x [ i ] [ j ] target > matrix[i][j] target>matrix[i][j],因为矩阵的每一行元素都是按升序排列的,那么在当前的搜索矩阵中,这一行元素都是小于 t a r g e t target target 的,因此可以将它们忽略,即将 x x x 增加 1。
- 如果 t a r g e t < m a t r i x [ i ] [ j ] target < matrix[i][j] target<matrix[i][j],因为矩阵的每一列元素都是按升序排列的,那么在当前的搜索矩阵中,这一列元素都是大于 t a r g e t target target 的,因此可以将它们忽略,即将 y y y 减少 1。
- 如果 t a r g e t = m a t r i x [ i ] [ j ] target = matrix[i][j] target=matrix[i][j],则说明找到目标值。
在搜索的过程中,如果超出了矩阵的边界,那么说明矩阵中不存在 t a r g e t target 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;
}
};
复杂度分析
- 时间复杂度: O ( m + n ) O(m+n) O(m+n)。由于 ( x , y ) (x, y) (x,y) 的初始值分别为 ( 0 , n − 1 ) (0, n-1) (0,n−1),因此 y y y 最多能被减少 n n n 次, x x x 最多能被增加 m m m 次,总搜索次数为 m + n m + n m+n。
- 空间复杂度: O ( 1 ) O(1) O(1)。