Search a 2D Matrix

Question:

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.

Solution:

    看到这个题目的第一想法是先对最右边一列做二分查找，定位是在哪一行，然后在这一行做二分查找。时间复杂度是O(logm)+O(logn)=O(logm+logn)=O(log(m*n))。

    这样需要两次二分查找，其实一次就可以了。把二维数组转化为一维数组。从左向右，从上向下依次取出每个元素，那么这些元素是整体有序的，可以看作一个一维数组，用二分查找解决。时间复杂度是O(log(m*n))，和上面的一样。

    开始实现这个二分查找代码的时候，begin和end记录的是两个点，这样代码写起来较复杂，见注释中的代码。后来begin和end改为转化为一维数组后的下标，这样就简单多了。代码如下，在leetcode上测试通过了。

class Solution {

public:

    bool searchMatrix(vector<vector<int> > &matrix, int target) {

        if (matrix.size() == 0)

            return false;

        int col_len = matrix[0].size();

        int row_len = matrix.size();

        int beg = 0;

        int end = row_len * col_len - 1;

        while (beg <= end) {

            int mid = beg + (end - beg) / 2;

            int k = matrix[mid/col_len][mid%col_len];

            if (target == k)

                return true;

            else if (target > k)

                beg = mid + 1;

            else

                end = mid - 1;

        }

        /* 

         * the following is another way, but more complex

         *

        int beg_row = 0;

        int beg_col = 0;

        int end_row = row_len - 1;

        int end_col = col_len - 1;

        while (end_row * col_len + end_col >= beg_row * col_len + beg_col) {

            int total = col_len - beg_col + end_col + 1 + col_len * (end_row - beg_row - 1);

            int k_col = (beg_col + (total / 2) % col_len) % col_len;

            int k_row = beg_row + (beg_col + (total / 2)) / col_len;

            if (target == matrix[k_row][k_col])

                return true;

            else if (target > matrix[k_row][k_col]) {

                beg_row = k_row + (k_col + 1) / col_len;

                beg_col = (k_col + 1) % col_len;

            } else {

                end_row = (k_col == 0) ? k_row - 1 : k_row;

                end_col = (k_col == 0) ? col_len - 1 : k_col - 1;

            }

        }

        */

        return false;

    }

private:

};

    这个题目让我想起了另外一个二维数组题目，二维数组每一行，从左到右有序，每一列，从上到下有序，也是查找一个数。方法是从右上角的元素开始比较大小，指针向下或向左移动，时间复杂度是O(m+n)。