二维矩阵查找元素相关问题

二维矩阵查找元素查找元素相关算法

在一个二维矩阵(n * m)中查找是否存在某个值，存在返回true, 否则返回false; 我们直接能想到的一个算法就是直接暴力枚举，这当然没错，最坏的时间复杂度就算 O(n * m), 但相关题目会给出矩阵的相关特点，以此来进行优化. 有时候面试题也并不是看你能不能AC过，而是给你条件看你如何相关优化朴素算法。

来看一道 LeetCode 的相关题目
题目链接 : Lc 74. 搜索二维矩阵

编写一个高效的算法来判断 m x n 矩阵中，是否存在一个目标值。该矩阵
具有如下特性：
. 每行中的整数从左到右按升序排列。
. 每行的第一个整数大于前一行的最后一个整数。

从上面的特性可以知道，每一行都是递增的，且每一行的第一个整数大于前一行的最后一个数， 即整个矩阵是递增的，如果将矩阵转化为一维的话，那么就算递增的， 对于这种单调递增的特点，我们可以实现O(logn)的时间复杂度，即二分查找的方法, 这样时间复杂度即为 O(log n*m); 故这里实现的关键是：

(1) 二维下标转化为对应的一维下标

下标从0开始， 在一个n * m 的二维数组中;
. arr[r][c] 其对应的一维下标为: r * m + c;
. 对于一维数组的第k个其在n * m 的位置为 arr[k / m][k % m];

(2) 二分查找算法

整数二分模板, 经典模板建议背过，可以避免一些烦人的边界问题

bool check(int x) {/* ... */} // 检查x是否满足某种性质

// 区间[l, r]被划分成[l, mid]和[mid + 1, r]时使用：
int bsearch_1(int l, int r)
{
    while (l < r)
    {
        int mid = l + r >> 1;
        if (check(mid)) r = mid; // check()判断mid是否满足性质
        else l = mid + 1;
    }
    return l;
}

// 区间[l, r]被划分成[l, mid - 1]和[mid, r]时使用：
int bsearch_2(int l, int r)
{
    while (l < r)
    {
        int mid = l + r + 1 >> 1;  //注意这里必须上取整 + 1, 不然l = mid, 可能在两个的情况下无限递归. 
        if (check(mid)) l = mid;   
        else r = mid - 1;         
    }
    return l;
}

上面的两个模板是二分两种情况的模板, 即当检查此时中间位置的值满足一定条件之后。
(1) 应该在左半部分查找，此时的 r = mid , 否则在右半部分查找时， l = mid + 1。

(2) 应该在右半部分查找，此时 l = mid, 否则应该在左半部分查找，r = mid - 1;

注意这两种代码的区别 : 区别在于对于上取整还是下取整的处理，bsearch_1中使用了 int mid = l + r >> 1; 即 (l + r) / 2; C++的整数除法是下取整的方式, 如果这里用了上取整会出现死循环, 若此时的更新为 int mid = l + r + 1 >> 1;
即上取整的方式, 则当二分查找到只有两个元素时, 即出现 r = l + 1这种情况时， int mid = (l + r + 1) / 2 = l + 1 = r, 若此时满足判断条件r会被更新为mid， 而此时mid就算r， 故就会陷入死循环, 故这里不能用上取整，同样道理
bsearch_2不能使用下取整，否则也会进入死循环.

C++实现代码

class Solution 
{
public:
    bool searchMatrix(vector<vector<int>>& matrix, int target) 
    {
        int n = matrix.size(), m = matrix[0].size();
        int l = 0, r = n * m - 1;
        while(l < r)
        {
            int mid = l + r >> 1;
            if(matrix[mid / m][mid % m] >= target) r = mid;
            else l = mid + 1;
        }
        // 上面的二分查找找的是大于等于target的第一个数, 故最后还是要判断是否为目标值 
        return target == matrix[l / m][l % m];  
    }
};

接下来再来看一道也是二维矩阵查找问题，不过这次给出的矩阵信息少了一个，在这种情况下的查找该如何进行优化。
相关题目链接: AcWing 15. 二维数组中的查找

在一个二维数组中
. 每一行都按照从左到右递增的顺序排序
. 每一列都按照从上到下递增的顺序排序。

这里的话这个二维矩阵并不是一个严格递增的，故这里的话不能二分直接来做。但是观察之后我们发现对于这样一个矩阵, 可以发现这个矩阵有如下的规律 :

故我们发现其右上角的元素有如上规律, 我们只需比较矩阵右上角的值和当前目标值的大小关系即可, 若右上角的值小于目标值, 表示右上角所在的当前行的元素均小于目标值，直接将这一行剔除即可, 同样若此时右上角的值大于目标值，则表示此时右上角所在的那一列的值都大于目标值，故我们需要把这一列剔除。然后我们继续比较新矩阵中的右上角的值与目标值的大小关系。直到到达边界仍未找出，即说明该矩阵并没有改目标值，这样的话时间复杂度最坏为 O(n + m); 相比于暴力的O(n * m) 有优化.

C++代码实现

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