小黑实习最后一周，穿上正装假装成长，去医院面试后和尚香疯狂的leetcode之旅:576. 出界的路径数

爱喝喜茶爱吃烤冷面的小黑黑

已于 2023-02-17 14:12:14 修改

阅读量77

点赞数

分类专栏：小黑的日常leetcode之旅文章标签：面试 leetcode 算法

于 2023-02-17 14:06:34 首次发布

本文链接：https://blog.csdn.net/qq_37418807/article/details/129075277

版权

小黑的日常leetcode之旅专栏收录该内容

225 篇文章 1 订阅

订阅专栏

记忆化搜索

class Solution:
    def findPaths(self, m: int, n: int, maxMove: int, startRow: int, startColumn: int) -> int:
        cache = [[[0] * (maxMove+1) for _ in range(n)] for _ in range(m)]
        def dfs(moveCount, i, j):
            # 判定是否出界
            if i >= m or i < 0 or j >= n or j < 0:
                return 1
            # 判断步数是否用完
            if not moveCount:
                return 0
            # 判断该点是否无法移动出去，剪枝
            if i + moveCount < m and i - moveCount >= 0 and j + moveCount < n and  j - moveCount >= 0:
                return 0 

            if cache[i][j][moveCount]:
                return cache[i][j][moveCount]
            sum_ = 0

            for move in [(-1, 0), (1, 0), (0, 1), (0, -1)]:
                sum_ = int((sum_ + dfs(moveCount-1, i + move[0], j + move[1])) % (1e9 + 7))
            cache[i][j][moveCount] = sum_
            return cache[i][j][moveCount]
        p = dfs(maxMove, startRow, startColumn)
        return p

在这里插入图片描述

动态规划

class Solution:
    def findPaths(self, m: int, n: int, maxMove: int, startRow: int, startColumn: int) -> int:
        # 动态规划矩阵维度：[maxMove, m, n]
        dp = [[[0] * n for _ in range(m)] for _ in range(maxMove+1)]
        # 探测的邻居相对坐标
        neigbers = [(0, -1), (0, 1), (1, 0), (-1, 0)]
        # 开始动态规划推导
        for k in range(1, maxMove+1):
            for i in range(m):
                for j in range(n):
                    # 往边界走
                    if i == 0:
                        dp[k][i][j] += 1
                    if j == 0:
                        dp[k][i][j] += 1
                    if i == m - 1:
                        dp[k][i][j] += 1
                    if j == n - 1:
                        dp[k][i][j] += 1
                    # 进行动态规划计算
                    for nei in neigbers:
                        if 0 <= nei[0] + i < m and 0 <= nei[1] + j < n:
                            dp[k][i][j] = (dp[k][i][j] + dp[k-1][nei[0] + i ][nei[1] + j]) % (1e9 + 7)
                            
        return int(dp[maxMove][startRow][startColumn])

在这里插入图片描述

动态规划内存优化

class Solution:
    def findPaths(self, m: int, n: int, maxMove: int, startRow: int, startColumn: int) -> int:
        # 初始化动态规划数组 m * n
        dp = [[0] * n for _ in range(m)]
        # 开始动态规划计算
        for k in range(1, maxMove+1):
            temp = [[0] * n for _ in range(m)]
            moves = [(1, 0), (-1, 0), (0, 1), (0, -1)]
            for i in range(m):
                for j in range(n):
                    # 边界
                    if i == 0:
                        temp[i][j] += 1
                    if j == 0:
                        temp[i][j] += 1
                    if i == m - 1:
                        temp[i][j] += 1
                    if j == n - 1:
                        temp[i][j] += 1
                    # 汇集周围
                    for move in moves:
                        if 0 <= move[0] + i < m and 0 <= move[1] + j < n:
                            temp[i][j] = int((temp[i][j] + dp[move[0] + i][move[1] + j]) % (1e9 + 7))
            dp = temp
            temp = [[0] * n for _ in range(m)]
        return dp[startRow][startColumn]