leetcode 二维矩阵查找

从矩阵右上角出发，若目标小于当前所指，那么向右找值更小的，列数-1；若目标大于当前所指，那么行数加一，向下找值更大的。本质还是以行为中心查找。

class Solution {
public:
    bool searchMatrix(vector<vector<int>>& matrix, int target) {
        if(matrix.empty()||matrix[0].empty())
            return false;
        int rowsize=matrix.size();
        int columnszie=matrix[0].size();
        int row=0,column=columnszie-1;
        while(row<rowsize&&column>=0)
        {
            if(matrix[row][column]==target)
                return true;
            else if(matrix[row][column]<target)
                row++;
            else
                column--;
        }
        return false;
    }
};

还有DFS解答方法，内存占用大

class Solution {
public:
    int m,n;
    int N=999999;

    bool dfs(vector<vector<int>>& matrix,int i,int j,int target)
    {
        
        if(i<0||i>=m||j<0||j>=n) return false;
        if(matrix[i][j]==N) return false;
        //搜到已经经过的比target小的元素，设为N，标记
        if(matrix[i][j]==target) return true;
        if(matrix[i][j]>target) return false;
        matrix[i][j]=N;
        bool x=dfs(matrix,i,j+1,target);
        bool y=dfs(matrix,i+1,j,target);
        //向下寻找，向右寻找，向数更大的方向寻找，从（0，0）出发肯定存在一条路径，该条路径上所有点都比
        //target小，（由矩阵特点可知）
        return x||y;
    }

    bool searchMatrix(vector<vector<int>>& matrix, int target) {
        m=matrix.size();
        if(m==0)
        return false;
        n=matrix[0].size();
        if(n==0) 
        return false;
        return dfs(matrix,0,0,target);
        //从0开始递归
    }
};