算法python329. 矩阵中的最长递增路径

2022.07.20
今年的蓝桥杯有些遗憾，21年7月份听说后端好找工作，就去学Java；今年有听说前端工资高，比较轻松，又在犹豫。在经过一番思考之后，选择自己感兴趣的方向。

329. 矩阵中的最长递增路径

普通DFS会超时

class Solution(object):
    def longestIncreasingPath(self, matrix):
        """
        :type matrix: List[List[int]]
        :rtype: int
        """
        if not matrix: # 矩阵为空返回0
            return 0
        DIRS = [(-1, 0), (1, 0), (0, -1), (0, 1)]
        def dfs(row, column):
            best = 1 # 初值为1
            for dx, dy in DIRS:
                newRow, newColumn = row + dx, column + dy
                if 0 <= newRow < rows and 0 <= newColumn < columns and matrix[newRow][newColumn] > matrix[row][column]:
                    best = max(best, dfs(newRow, newColumn) + 1)
            return best

        ans = 0
        rows, columns = len(matrix), len(matrix[0])
        for i in range(rows):
            for j in range(columns):
                ans = max(ans, dfs(i, j))
        return ans

记忆化递归 + DFS

class Solution(object):
    def longestIncreasingPath(self, matrix):
        """
        :type matrix: List[List[int]]
        :rtype: int
        """
        if not matrix:
            return 0
        m, n = len(matrix), len(matrix[0]) # 矩阵的行，矩阵的列
        DIRS = [(-1, 0), (1, 0), (0, -1), (0, 1)]
        def dfs(x0, y0):
            if (x0, y0) in dic:
                return dic[(x0, y0)]
            sub_res = 0
            for dx, dy in DIRS:
                x = x0 + dx
                y = y0 + dy
                if 0 <= x < m and 0 <= y < n and matrix[x][y] > matrix[x0][y0]:
                    sub_res = max(sub_res, dfs(x, y))
                    
            dic[(x0, y0)] = 1 + sub_res
            return dic[(x0, y0)] 
                
        res = 1
        dic = dict()
        for i in range(m):
            for j in range(n):
                res = max(res, dfs(i, j))
        return res

复杂度分析

时间复杂度：O($mn$)O($mn$)，其中 $m$ 和 $n$ 分别是矩阵的行数和列数。深度优先搜索的时间复杂度是 O($V$+$E$)，其中 $V$ 是节点数，$E$ 是边数。在矩阵中，O($V$)=O($mn$)，O($E$)$\approx$ O($4mn$) = O($mn$)。

空间复杂度：O($mn$)，其中 $m$ 和 $n$ 分别是矩阵的行数和列数。空间复杂度主要取决于缓存和递归调用深度，缓存的空间复杂度是 O($mn$)，递归调用深度不会超过 $mn$。