力扣 240. 搜索二维矩阵 II

厂里英才

于 2023-01-16 13:11:46 发布

阅读量179

点赞数

分类专栏：力扣文章标签： leetcode 算法 c++

本文链接：https://blog.csdn.net/qq_71654538/article/details/128702886

版权

力扣专栏收录该内容

18 篇文章 0 订阅

订阅专栏

1.题目

编写一个高效的算法来搜索 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
    -109 <= matrix[i][j] <= 109
    每行的所有元素从左到右升序排列
    每列的所有元素从上到下升序排列
    -109 <= target <= 109

来源：力扣（LeetCode）

2.思路及代码

2.1常规解法（二分查找 + 剪枝）

看到矩阵的特性不难想到二分，逐行查找即可。代码如下：

class Solution {
public:
    bool searchMatrix(vector<vector<int>>& matrix, int target) {
        int m = matrix.size(), n = matrix[0].size();
        //逐行查找
        for (int i = 0; i < m; ++i) {
            //该行最大的数都小于target，直接进入下一行
            if (target > matrix[i][n - 1]) continue;
            //该行最小的数都大于target,后面不可能再找到target,结束循环
            if (target < matrix[i][0]) break;
            int left = 0, right = n;
            //二分
            while (left < right) {
                int mid = left + (right - left) / 2;
                if (matrix[i][mid] > target) right = mid;
                else if (matrix[i][mid] < target) left = mid + 1;
                else return true;
            }
            left = 0;
            right = n;
        }
        return false;
    }
};

2.2玄学解法（二叉排序树）

我们从右上角看，会发现这个矩阵有些像二叉排序树，于是我们从右上角开始搜索，当搜索位置的值小于目标值就往下移，当搜索位置的值大于目标值就往左移。代码如下：

class Solution {
public:
    bool searchMatrix(vector<vector<int>>& matrix, int target) {
        int x = 0, y = matrix[0].size() - 1, x_max = matrix.size();
        while (x < x_max && y >= 0) {
            if (matrix[x][y] == target) {
                return true;
            //小于目标值下移
            } else if (matrix[x][y] < target) {
                ++x;
            //大于目标值左移
            } else {
                --y;
            }
        }
        return false;
    }
};

3.反思

最开始用常规解法的时候，明明思路没有问题，但是代码却莫名其妙超时了，代码如下：

class Solution {
public:
    //二分
    bool MidSearch(int left, int right, vector<int>arr, int target) {
        if (left > right) return false;
        int mid = (left + right) / 2;
        if (arr[mid] == target) {
            return true;
        } else if (arr[mid] < target) {
            return MidSearch(mid + 1, right, arr, target);
        } else {
            return MidSearch(left, mid - 1, arr, target);
        }
    }
    bool searchMatrix(vector<vector<int>>& matrix, int target) {
        for (int i = 0; i < matrix.size(); ++i) {
            if (matrix[i][0] > target) break;
            if (matrix[i][matrix[i].size() - 1] < target) continue;
            int left = 0, right = matrix[i].size() - 1;
            if (MidSearch(left, right, matrix[i], target)) return true;
        }
        return false;
    }
};

研究两个代码的区别后，我发现①成功通过的代码使用的是while，而我最初的代码使用的是递归，while执行的效率显然更高②我频繁调用size函数，并没有用int类型存储起来再调用。或许就是这些细微的差别，导致最初代码未能通过。我只能说细节决定成败。