leetcode算法题--二维数组中的查找

bob62856

已于 2023-07-02 09:53:16 修改

阅读量113

点赞数

分类专栏： Algorithm 文章标签：算法 leetcode 深度优先

于 2023-07-01 12:19:27 首次发布

本文链接：https://blog.csdn.net/qq_20817327/article/details/131489053

版权

Algorithm 专栏收录该内容

374 篇文章 3 订阅

订阅专栏

文章介绍了如何使用深度优先搜索（DFS）结合记忆化策略解决LeetCode中的二维数组查找问题，首先提供了一个O(log(n+m))的解决方案，然后优化为利用二维数组类似二叉排序树的性质，将时间复杂度降低到O(m+n)。

摘要由CSDN通过智能技术生成

原题链接：https://leetcode.cn/problems/er-wei-shu-zu-zhong-de-cha-zhao-lcof/

通过dfs+记忆化来解，应该是O(log(n + m))

func findNumberIn2DArray(matrix [][]int, target int) bool {
    n := len(matrix)
    if n == 0 {
       return false
    }
    m := len(matrix[0])
    if m == 0 {
        return false
    }
    memo := make([][]int, n)
    for i := range memo {
        memo[i] = make([]int, m)
        for j := range memo[i] {
            memo[i][j] = -1
        }
    }
    var dfs func(i, j int) bool
    dfs = func(i, j int) bool {
        if memo[i][j] != -1 {
            return memo[i][j] == 1
        }
        if i + 1 < n {
            d := matrix[i + 1][j]
            if d == target {
                return true
            }
            if d < target {
                if dfs(i + 1, j) {
                    return true
                }
            }
        }
        if j + 1 < m {
            r := matrix[i][j + 1]
            if r == target {
                return true
            }
            if r < target {
                if dfs(i, j + 1) {
                    return true
                }
            }
        }
        memo[i][j] = 0
        return false
    }
    if matrix[0][0] == target {
        return true
    }
    return dfs(0, 0)
}

优化方法，从右上角看，数组就想一个二叉排序树（Binary Sort Tree），那么就好做了，时间复杂度为O(m+n)

func findNumberIn2DArray(matrix [][]int, target int) bool {
    n := len(matrix)
    if n == 0 {
        return false
    }
    m := len(matrix[0])
    if m == 0 {
        return false
    }
    i, j := 0, m - 1 
    for i < n && j >= 0 {
        num := matrix[i][j]
        if target == num {
            return true
        } else if target > num {
           i++  
        } else {
           j-- 
        }
    } 
    return false
}