LeetCode-741. 摘樱桃【数组动态规划矩阵】

题目描述：
解题思路一：动态规划，定推初遍举。
解题思路二：倒序循环
解题思路三：0

题目描述：

给你一个 n x n 的网格 grid ，代表一块樱桃地，每个格子由以下三种数字的一种来表示：

0 表示这个格子是空的，所以你可以穿过它。
1 表示这个格子里装着一个樱桃，你可以摘到樱桃然后穿过它。
-1 表示这个格子里有荆棘，挡着你的路。
请你统计并返回：在遵守下列规则的情况下，能摘到的最多樱桃数：

从位置 (0, 0) 出发，最后到达 (n - 1, n - 1) ，只能向下或向右走，并且只能穿越有效的格子（即只可以穿过值为 0 或者 1 的格子）；
当到达 (n - 1, n - 1) 后，你要继续走，直到返回到 (0, 0) ，只能向上或向左走，并且只能穿越有效的格子；
当你经过一个格子且这个格子包含一个樱桃时，你将摘到樱桃并且这个格子会变成空的（值变为 0 ）；
如果在 (0, 0) 和 (n - 1, n - 1) 之间不存在一条可经过的路径，则无法摘到任何一个樱桃。

示例 1：

输入：grid = [[0,1,-1],[1,0,-1],[1,1,1]]
输出：5
解释：玩家从 (0, 0) 出发：向下、向下、向右、向右移动至 (2, 2) 。
在这一次行程中捡到 4 个樱桃，矩阵变成 [[0,1,-1],[0,0,-1],[0,0,0]] 。
然后，玩家向左、向上、向上、向左返回起点，再捡到 1 个樱桃。
总共捡到 5 个樱桃，这是最大可能值。

示例 2：

输入：grid = [[1,1,-1],[1,-1,1],[-1,1,1]]
输出：0

提示：

n == grid.length
n == grid[i].length
1 <= n <= 50
grid[i][j] 为 -1、0 或 1
grid[0][0] != -1
grid[n - 1][n - 1] != -1

解题思路一：动态规划，定推初遍举。

定义 $f[k][x_1][x_2]$
表示两个人（设为 A 和 B）从0出发，分别到达 $x_1,k-x_1)$ 和 $x_2,k-x_2)$ 摘到的樱桃个数之和的最大值。
推导公式，只能向下或向右走
所以 $f[k][x_1][x_2]$ 可以由四种可能得情况得到：【x1, x2可以看作是行】
1. 都往右：从 $f[k-1][x_1][x_2]$ 转移过来；
2. A 往下，B 往右：从 $f[k-1][x_1-1][x_2]$ 转移过来；
3. A 往右，B 往下：从 $f[k-1][x_1][x_2-1]$ 转移过来；
4. 都往下：从 $f[k-1][x_1-1][x_2-1]$ 转移过来；
初始化
因为遇到荆棘，则令为负无穷大。
f = [[[-inf] * n for _ in range(n)] for _ in range(n * 2 -1 )]
f[0][0][0] = grid[0][0]
遍历方向

for k in range(1, n * 2 - 1):
            for x1 in range(max(k - n + 1, 0), min(k + 1, n)):
                y1 = k - x1
                if grid[x1][y1] == -1:
                    continue
                for x2 in range(x1, min(k + 1, n)):

举例

class Solution:
    def cherryPickup(self, grid: List[List[int]]) -> int:
        n = len(grid)
        f = [[[-inf] * n for _ in range(n)] for _ in range(n * 2 -1 )]
        f[0][0][0] = grid[0][0]
        for k in range(1, n * 2 - 1):
            for x1 in range(max(k - n + 1, 0), min(k + 1, n)):
                y1 = k - x1
                if grid[x1][y1] == -1:
                    continue
                for x2 in range(x1, min(k + 1, n)):
                    y2 = k - x2
                    if grid[x2][y2] == -1:
                        continue
                    res = f[k-1][x1][x2] # 都往右
                    if x1:
                        res = max(res, f[k-1][x1-1][x2]) # 往下，往右
                    if x2:
                        res = max(res, f[k-1][x1][x2-1]) # 往右，往下
                    if x1 and x2:
                        res = max(res, f[k-1][x1-1][x2-1]) # 都往下
                    res += grid[x1][y1]
                    if x2 != x1: # 避免重复摘同一个樱桃
                        res += grid[x2][y2]
                    f[k][x1][x2] = res
        print(f)
        return max(f[-1][-1][-1], 0)

时间复杂度：O(n³)
空间复杂度：O(n²)

解题思路二：倒序循环

class Solution:
    def cherryPickup(self, grid: List[List[int]]) -> int:
        n = len(grid)
        f = [[-inf] * n for _ in range(n)]
        f[0][0] = grid[0][0]
        for k in range(1, n * 2 - 1):
            for x1 in range(min(k, n - 1), max(k - n, -1), -1):
                for x2 in range(min(k, n - 1), x1 - 1, -1):
                    y1, y2 = k - x1, k - x2
                    if grid[x1][y1] == -1 or grid[x2][y2] == -1:
                        f[x1][x2] = -inf
                        continue
                    res = f[x1][x2]  # 都往右
                    if x1:
                        res = max(res, f[x1 - 1][x2])  # 往下，往右
                    if x2:
                        res = max(res, f[x1][x2 - 1])  # 往右，往下
                    if x1 and x2:
                        res = max(res, f[x1 - 1][x2 - 1])  # 都往下
                    res += grid[x1][y1]
                    if x2 != x1:  # 避免重复摘同一个樱桃
                        res += grid[x2][y2]
                    f[x1][x2] = res
        return max(f[-1][-1], 0)