想请问一下array.empty()不是就能确认array是不是空数组了吗，为什么还要加一个array[0].empty()呢？

我也不太懂不过测试了一下，不加array[0].empty()不管是Acwing还是LeetCode都能AC

array可能不是empty，比如包含一个空的vector，这样array.empty() 为false，但是array[0].empty()为true

能举一个具体的例子吗？

[[ ][ ][ ]]应该是这样，外面的[]里面包含若干空的vector[]，所以array.empty()为false，但里面的vector是空的，array[0].empty()为true。[ ]这样的情况，array.empty()才是true。

是的是的 tql

我不加ac不了

请问如果是[[][1, 2][2, 3]]呢，这样不会误判吗

那就不是矩阵了

为什么不用array.size()==0 return false; 呢

if(array.empty()||array[0].empty())return false;
这个语句中array.empty()和array[0].empty()的位置反过来这个题过不了。这个位置为啥还有讲究啊？

因为有[]选项，它的array[0]是不存在的，需要先判断array为空，if语句就不会看后面了

奥~是这样啊 谢谢你~

为什么只检查了第一行是否为空的情况，如果第一行不为空，但是其他行为空呢？这样不会出现问题吗？

只判断了array[0].empty();不应该所有行都判断是否为空最合理吗？

递归搜索，每次丢弃1/4，时间复杂度O(logm + logn)

class Solution {
public:
    int t;
    vector<vector<int>> array;
    bool searchArray(vector<vector<int>> array, int target) {
        int n = array.size();
        if (n == 0) return false;
        int m = array[0].size();
        this->t = target;
        this->array = array;
        return find(0, n - 1, 0, m - 1);
    }

    bool find(int x1, int x2, int y1, int y2)
    {
        if (x1 > x2 || y1 > y2) return false;
        int xmid = x1 + x2 >> 1;
        int ymid = y1 + y2 >> 1;
        if (array[xmid][ymid] == t) return true;
        if (array[xmid][ymid] > t) return find(x1, xmid - 1, y1, y2) || find(xmid, x2, y1, ymid - 1);
        else return find(xmid + 1, x2, y1, y2) || find(x1, xmid, ymid + 1, y2);
    }
};

太牛了

you le mei

class Solution {
public:
    bool searchArray(vector<vector<int>> array, int target) {
        if(array.empty() || array[0].empty()) return false;
        for(int i = 0, j = array[0].size() - 1; i < array.size(), j >= 0; ){
            if(array[i][j] == target) return true;
            else if(array[i][j] > target) j--;
            else i ++;
        }
        return false;
    }
};

为什么这样当target比矩阵中元素都大的时候就会segmentation fault？？

因为你的for条件是逗号运算符

条件判断用&&应该就行

class Solution {
public:
    bool searchArray(vector<vector<int>> a, int t) {
        if(a.empty()||a[0].empty())return false;
        int n=a.size(),m=a[0].size();
        int i=n-1,j=0;
        while(i>=0&&j<m){
            if(t==a[i][j])return true;
            else if(t>a[i][j])j++;
            else i--;
        }
        return false;
    }
};

从左上角枚举

这个应该是从左下角开始枚举的吧

依次对列，行做二分查找，时间复杂度更低o(log(nm))

不行吧，代码呢

class Solution {
public:
    bool searchArray(vector<vector<int>> array, int target) {
        if(array.size() == 0) return false;

        //m为行，n为列
        int m = array.size(),n = array[0].size();

        // cout << n << ' ' << m << endl;
        //找到最后一个<=target的列
        int l = 0,r = n - 1;
        while(l < r)
        {
            int mid = l + r + 1 >> 1;
            if(array[0][mid] <= target) l = mid;//？符号的表示
            else r = mid - 1;
        }
        // cout << l << endl;
        if(array[0][l] == target) return true;//等于就直接结束
        //找到列，最后一个<=target的行
        int lm = 0,rm = m - 1;
        while(lm < rm)
        {
            int mid = lm + rm + 1 >> 1;
            if(array[mid][l] <= target) lm = mid;
            else rm = mid - 1;
        }
        if(array[lm][l] == target) return true;

        return false;
    }
};

/*


*/

你的写法有问题。会漏掉部分答案。
我构造一个数据给你：

[
[1,2, 3, 4, 6],
[2,2, 3, 4, 7],
[3, 4, 6, 6, 7],
[4, 5, 6, 7, 8]
]

target = 5。

题目里面说的应该是严格递增

看了下，没有提到。而且就算是严格递增也是错的。

[
[1, 2, 4, 7, 10],
[2, 3, 6, 9, 11],
[3, 4, 7, 10 , 12],
[4, 5, 8, 11, 13]
]

target = 5

老哥牛

class Solution {
public:
    bool searchArray(vector<vector<int>> array, int target) {

        int n = array.size();
        for(int i=0;i<n;i++){
            vector alls(array[i]);
            if(alls.size()==0) return false;
            int l = 0;
            int r = alls.size()-1;

            while(l<r){
                int mid = (l + r)/2;
                if(alls[mid]>=target) r = mid;
                else l = mid + 1;
            }

            if(alls[l] == target) return true;
        }
        return false;
    }
};

递归搜索，时间复杂度o(logm + logn)

class Solution {
public:
    int t;
    vector<vector<int>> array;
    bool searchArray(vector<vector<int>> array, int target) {
        int n = array.size();
        if (n == 0) return false;
        int m = array[0].size();
        this->t = target;
        this->array = array;
        return find(0, n - 1, 0, m - 1);
    }

    bool find(int x1, int x2, int y1, int y2)
    {
        if (x1 > x2 || y1 > y2) return false;
        int xmid = x1 + x2 >> 1;
        int ymid = y1 + y2 >> 1;
        if (array[xmid][ymid] == t) return true;
        if (array[xmid][ymid] > t) return find(x1, xmid - 1, y1, y2) || find(xmid, x2, y1, ymid - 1);
        else return find(xmid + 1, x2, y1, y2) || find(x1, xmid, ymid + 1, y2);
    }
};

直接暴力循环O(n2)也能过，是不是应该加强一下数据 - -

剑指offer的题考察注重怎么优化吧= =

if (array[i][j] > target) j – ;
else i ;
或者
if (array[i][j] > target) j – ;
if(array[i][j] < target) i;
或者
if(array[i][j] < target) i;
else j–;
都过了；
但是写成如下：
if(array[i][j] < target) i;
if(array[i][j] > target) j–; 会报segmentation fault，为什么呢？

我也有这个疑问，请问您解决了没

如果把这两行颠倒过来，就是先写下面那行，然后在判断是否为空，它会报segmentation fault，就是输入空数组，没有输出。为什么会这样？
if (array.empty() || array[0].empty()) return false;
int i = 0, j = array[0].size() - 1;

交换之后可能会访问到不存在的下标。

对空数组进行 int row=array.size() 操作没问题，但col=array[0].size() 操作，报 Segmentation Fault。意思是空数组size为0，但是不存在array[0];还是说存在array[0],但是array[0]不能进行size()操作？

不存在array[0]。

样例不够完整，似乎样例都是方阵？

有6个数据不是方阵。

一开始写的代码没注意不是方阵，沿着对角线扫的，从而确定在那一行或者那一列的那一段，然后找从里面找的，但却AC了

私信我一下错误代码，我们来加强个数据。

光看描述我觉的应该可以出现不是矩形的情况， 有的行应该可以是凹凸的，是我理解错了吗？

先写 if (array[i][j] > target) j – ; else i ++ ;再写if (array[i][j] == target) return true; 为什么就不对了？？
这俩也没有交集 啊？？？？

先写if (array[i][j] > target) j – ; else i ++ ; else 里面的隐含条件就是array[i][j] <=target 所以如果array[i][j] == target这个条件成立则运行i++这个条件，则就不会运行后面的if (array[i][j] == target) return true;

厉害

楼上同学解释地不错。

为什么这些题目偏要用return，不可以用输入输出？？

这里只是写函数，不是写完整的程序

评测器中已经帮大家把输入输出写好了。

左下角也是可以的

对滴，左下角和右上角是对称的，都是可以的~

你好，我是新手小白，我想问一下array.empty( ) || array[0].empty( )是什么意思？我查了资料是不是这两句话的作用是表示二维数组是空的，array.empty( )的意思是该二维数组是一个零行的数组， array[0].empty( )表示该二维数组是一个零列的数组，使用或条件，表示只要满足其一，该二维数组是一个空的二维数组，谢谢你。

对滴。在leetcode上可以把这句话去掉试试，如果不对了会给出错误数据，一目了然。

真的谢谢你。