leetcode - 240.Search a 2D Matrix II

算法系列 — leetcode

题目描述：
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 in ascending from left to right.
• Integers in each column are sorted in ascending from top to bottom.

If there is an element equal to the value, return True; otherwise return False.

---

最最理想的解法，复杂度为O(m+n)，不过我并没有想到

直接从矩阵的右上角开始搜索, 用mark表示搜索位的所有信息
       如果target = mark，找到返回True
       如果target > mark，则向下搜索
       如果target < mark，则向左搜索
直至出界，则说明没有这个元素，返回False

矩阵每行都是从左至右升序，每列都是从上到下升序，如果target在矩阵中某个位置
初始mark在整个矩阵的右上角，所以target在其左下方
每次搜索只移动一步，移动的规则也总是能够保证移动之后target仍然是在mark左下方
那么在经过有限步移动之后target必然和mark重合
mark向下最多移动m步，向左最多移动n步，因而时间复杂度为O(m+n)

 def searchMatrix(matrix, target):
    i = 0
    j = len(matrix[0])
    while i < len(matrix) and j >= 0:
        if matrix[i][j] == target:
            return True

        if matrix[i][j] < target:
            i++
        else :
            j--

    return False

无论怎样看，这个解法都非常精简优雅，不过，我最初的目的是要练习分治算法，似乎这个解法里面并没有分治的思想

---

暴力枚举配合二分法

由于每行和每列都是有序的，很容易就能想到对每行(或每列)进行二分搜索
不难分析算法时间复杂度为O(N*logM)或者O(M*logN)

def searchMatrix(matrix, target):
    cols = len(matrix[0])
    for x in range(0, len(matrix)):
        if matrix[x][0] <= target && matrix[x][cols-1] >= target && binarySearch(matrix[x], target):
            return True
    return False

def binarySearch(li, target):
    start = 0
    end = len(li) - 1
    while(end > start):
        mid = int((start + end) / 2)
        if target == li[mid]:
            return True
        elif target > li[mid]:
            start = mid + 1
        else :
            end = mid - 1
    return li[end] == target

这个算法看起来就既没有技术含量也没有上面的那个算法优雅了，不过至少不是O(M*N)

---

分治思想配合二分法

由于给定的矩阵比较特殊，每行每列均是升序的，因而可以缩小矩阵规模以分治
最简单的就是将矩阵二等分或者四等分，但是矩阵各个部分都是不同的，因此很难通过减少重复动作来降低复杂度
只能通过剪枝来减小递归系数，而等分矩阵很难进行剪枝
从剪枝这个角度入手，自然是想将矩阵中不可能存在target的部分给抛弃掉

假设matrix[i][j] < target，那么它左上方的子矩阵便可全部抛弃
如果还有matrix[i+1][j+1] > target, 那么此元素右下方的子矩阵也可全部抛弃
因而只需要对matrix[i][j]左下方和右上方的两个子矩阵再进行查找，然后将两个结果归并起来即可
注意到对角线（i=j，在矩阵中不是很严格）上的元素也是升序的，因而可以通过二分查找来确定这个划分矩阵的关键元素

此处的复杂度分析涉及到两个变量，且关键元素位置不是确定的，因而比较困难，我再研究研究
不过估算应该是介于O(M*logN)和O(M+N)之间的； 边界条件不再累述，代码之中会有所反映

def _searchMatrix(matrix, target):
    return searchMatrix(matrix, target, 0, 0, len(matrix)-1, len(matrix[0])-1)

def searchMatrix(matrix, target, si, sj, ei, ej):
    if si > ei or sj > ej or target < matrix[si][sj]:
        return False
    if si == ei:
        for j in range(sj, ej+1):
            if target == matrix[si][j]:
                return True
        return False
    elif sj == ej:
        for i in range(si, ei+1):
            if target == matrix[i][sj]:
                return True
        return False


    start = 0
    end = min((ei - si), (ej - sj))
    while end > start + 1:
        mid = int((start + end) / 2)
        if target > matrix[si + mid][sj + mid]:
            start = mid
        elif target < matrix[si + mid][sj + mid]:
            end = mid
        else :
            return True

    if target > matrix[si+start+1][sj+start+1]:
        start += 1
    elif target == matrix[si+start+1][sj+start+1] \
        or target == matrix[si+start][sj+start]:
        return True
    return searchMatrix(matrix, target, si+start+1, sj, ei, sj+start) or searchMatrix(matrix, target, si, sj+start+1, si+start, ej)

这个算法虽然没有第一个算法那么简洁并且高效，比第二个算法看上去也复杂了一点，
在这个问题上也没有收获到很大的成果，但是在这个过程中对分治的思想训练很有帮助
作为刚上路的菜鸟，慢慢学吧，总会好的