解法1：暴力

如果按照一维的情况考虑，就是一个二分查找的问题， 那么对于一个矩阵而言，显然可以做次二分查找。
时间复杂度：
代码：

class Solution {
public:
    bool Find(int target, vector<vector<int> > array) {
        if(array.size() == 0 || array[0].size() == 0)
        {
            return false;
        }

        for(int i = 0 ; i < array.size(); i++)
        {
            int l = 0, r = array[i].size();

            while(l < r)
            {
                int mid = (r - l) / 2 + l;
                if(array[i][mid] < target)
                {
                    l = mid + 1;
                }
                else if (array[i][mid] > target)
                {
                    r = mid;
                }
                else{
                    return true;
                }
            }
        }
        return false;
    }
};

解法2：利用数组特性。

这个数组的特点是从上到下递增，从左到右递增。
考虑4角：
左上角：从上到下递增，从左到右递增
右下角：从右到左递减，从下到上递减
对于这两种情况不好利用，原因在于：两个方向都分别递增或递减，以左上角为例，如果当前数比要查找的数小时，显然要找更大的数，然而无法确定往右走还是往下走（都是递增的）。

左下角：从下到上递减，从左到右递增。
右上角：从上到下递增，从右到左递减。

利用这样的特性就能够找到相应数组，以左下角为例，当前数小于目标值时，应该找更大的，往右走，反之往上走即可。
边界条件：碰到边界时停止。
最多往上走次， 往右走次
时间复杂度为
代码如下（以左下角为例）

class Solution {
public:
    bool Find(int target, vector<vector<int> > array) {
        if(array.size() == 0 || array[0].size() == 0)
        {
            return false;
        }
        int col = 0;
        int row = array.size()-1;

        while(col < array[0].size() && row >= 0)
        {
           if(array[row][col] == target)
               return true;
            else if(array[row][col] < target)
            {
                // 要找更大的，往右走
                col++;
            }
            else{ // 要找更小的，往上走
                row--;
            }
        }

        return false;
    }
};