二分搜索变形

本来是一道很普通的水题，但是水出了质量。

一个矩阵元素满足，左->右 and 上->下 递增，问是否含有target数值。

暴力搜索(python)：

class Solution:
    def searchMatrix(self, matrix: list[list[int]], target: int) -> bool:
        for i in matrix:
            if target in i:
                return True
        return False

然后想了个进阶一点的，迭代类型的dfs：

简单分析了以下数据分布：

　　从右上开始寻找一个元素，优先右移搜索，直到元素 >or= target

　　　　然后下移搜索，直到元素 >or= target

　　　　　　如果右and下都有>target，那么左移同时处理当前点(防止死循环)

　　　　　　　　出循环后，检测x,y下标范围和元素是否等于target

class Solution
{
    int m, n;
    bool ck(int x, int y)
    {
        return 0 <= x && x < m && 0 <= y && y < n;
    }

public:
    bool searchMatrix(vector<vector<int>> &matrix, int target)
    {
        m = matrix.size(), n = matrix[0].size();
        int x = 0, y = 0;
        while (ck(x, y) && matrix[x][y] != target)
        {
            //优先左移
            if (ck(x, y + 1) && matrix[x][y + 1] <= target)
                ++y;
            else if (ck(x + 1, y) && matrix[x + 1][y] <= target)
                ++x;
            else
                matrix[x][y] = target + 1, --y;
        }
        return ck(x, y) && matrix[x][y] == target;
    }
};

再进阶一点的，

　　利用二分搜索了，很巧妙的是从右上角(左下角也行)开始搜索，

　　　　思维很简单，如果二分的mid处理，然后就是左移或者下移直到找到or出界

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 && 0 <= y)
        {
            if (matrix[x][y] == target)
                return true;
            matrix[x][y] < target ? ++x : --y;
        }
        return false;
    }
};

【刚看到这个题的时候，如果我用二分搜索的话，我更可能会直接转存为一维数组然后find了】

【Over】

 

搜索

复制