（LeetCode74）Search a 2D Matrix

Write an efficient algorithm that searches for a value in an m x n matrix. This matrix has the following properties:

• Integers in each row are sorted from left to right.
• The first integer of each row is greater than the last integer of the previous row.

For example,

Consider the following matrix:

[
  [1,   3,  5,  7],
  [10, 11, 16, 20],
  [23, 30, 34, 50]
]

Given target = 3, return true.

题目：

在一个m*n二维数组中，每一行从左到右递增，每一行的第一个元素比上一行最后一个元素大。

判断某个元素是否在 该数组中。

思路：

问题隐含的一个信息就是：每一列也从上到下递增。

方法1：

将二维数组按行展开的话，就是一个排序的一维数组，因此通过一维数组的二分查找很容易得到答案。

方法2：

鉴于数组的规律性，选取数组查找范围的右上角数字，如果与查找的数字相等， 则返回true，如果比查找的数字大，则将该数字所在列从查找范围剔除，如果比查找数字小，则将该数字所在行从查找范围中剔除。

方法3：

先通过二分查找元素所在的行，再在所在行通过二分查找元素。

代码：

1、一维数组方法：

class Solution {
public:
    bool searchMatrix(vector<vector<int> > &matrix, int target) {
        int rows=matrix.size();
        int cols=matrix[].size();
        int left=,right=(rows*cols-);
        int mid,r,c,val;
        while(left<=right){
            mid=left+((right-left)>>);
            r=mid/cols;
            c=mid%cols;
            if(matrix[r][c]==target)
                return true;
            if(matrix[r][c]<target)
                left=mid+;
            else
                right=mid-;
        }
        return false;
    }
};

2、右上角元素比较方法

class Solution {
public:
    bool searchMatrix(vector<vector<int> > &matrix, int target) {
        int rows=matrix.size();
        int cols=matrix[].size();
        int r=,c=cols-;
        while(r<rows && c>=){
            if(target==matrix[r][c])
                return true;
            if(target<matrix[r][c])
                c--;
            else
                r++;
        }
        return false;
    }
};

3、二分查找行方法

class Solution {
public:
    bool searchMatrix(vector<vector<int> > &matrix, int target) {
        int rows=matrix.size();
        int cols=matrix[].size();
        int lRow=,rRow=rows-;
        int midRow;
        while(lRow<=rRow){
            midRow=lRow+((rRow-lRow)>>);
            if(matrix[midRow][]==target || matrix[midRow][cols-]==target)
                return true;
            if(matrix[midRow][]<target && matrix[midRow][cols-]>target)
                break;
            if(matrix[midRow][]>target)
                rRow=midRow-;
            else
                lRow=midRow+;
        }

        if(lRow<=rRow){
            int lCol=,rCol=cols-;
            int midCol;
            while(lCol<=rCol){
                midCol=lCol+((rCol-lCol)>>);
                if(matrix[midRow][midCol]==target)
                    return true;
                if(matrix[midRow][midCol]>target)
                    rCol=midCol-;
                else
                    lCol=midCol+;
            }
        }

        return false;
    }
};