# 741. 摘樱桃 (Hard)

## 问题描述

[741. 摘樱桃][link] (Hard)

[link]: https://leetcode.cn/problems/cherry-pickup/

给你一个 `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：**

![](https://pic-upyun.zwyyy456.tech/smms/2023-12-26-065425.jpg)

```
输入：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`

## 解题思路

这题从思路上说，其实是一道比较常规的 DP。但是要处理的细节很多。

一来一回取樱桃，其实就相当于两个人分别从 $[0, 0]$ 到 $[n - 1, n - 1]$。

我们以 $k$ 表示走的步数，$x1$ 表示第一个人当前的 $x$ 轴坐标，$x2$ 表示第二个人当前的 $x$ 轴坐标，第一个人当前坐标即 $k - x_1$，第二个人是 $k - x_2$。

$dp[k][x_1][x_2]$ 表示两个人各走了 $k$ 步，分别走到 $(x_1, k - x_1)$ 处和 $(x_2, k - x_2)$ 处摘得的樱桃。

$(k, x_1, x_2)$ 可能从 $(k - 1, x_1 - 1, x_2), (k - 1, x_1 - 1, x_2 - 1), (k - 1, x_1, x_2), (k - 1, x_1, x_2 - 1)$ 这四种情况转移过来，因此，考虑转移方程：

- 如果 $x_1 = x_2$，则 $dp[k][x_1][x_2] = dp[k - 1][prex_1][prex_2] + grid[x_1][y_1]$；
- 否则，$dp[k][x_1][x_2] = dp[k - 1][prex_1][prex_2] + grid[x_1][y_1] + grid[x_2][y_2]$；

$dp[k - 1][prex_1][prex_2]$ 是上述四种情况的最大值，注意，如果碰到荆棘应该取 $dp[k][x_1][x_2] = -\infty$ 而不是 $0$，以表示不能通过。

## 代码

```cpp
class Solution {
  public:
    int cherryPickup(vector<vector<int>> &grid) {
        // dp[k][x1][x2] 表示两点分别从 (x1, k - x1) 和 (x2, k - x2) 出发所能收集到的最多樱
        int n = grid.size();
        vector<vector<vector<int>>> dp(2 * n + 1, vector<vector<int>>(n, vector<int>(n, INT_MIN)));
        vector<vector<int>> mov{{-1, 0}, {-1, -1}, {0, -1}, {0, 0}};
        dp[0][0][0] = grid[0][0];
        for (int i = 1; i <= 2 * n - 2; ++i) {
            for (int x1 = 0; x1 <= i && x1 < n; ++x1) {
                for (int x2 = 0; x2 <= x1 && x2 < n; ++x2) {
                    int y1 = i - x1, y2 = i - x2;
                    if (y1 < 0 || y1 >= n || y2 < 0 || y2 >= n) {
                        continue;
                    }
                    if (grid[x1][i - x1] == -1 || grid[x2][i - x2] == -1) {
                        dp[i][x1][x2] = INT_MIN;
                        continue;
                    }
                    int tmp = INT_MIN; // 这里 tmp 也必须取无穷小
                    for (int j = 0; j < 4; ++j) {
                        int prex1 = x1 + mov[j][0], prey1 = i - 1 - prex1;
                        int prex2 = x2 + mov[j][1], prey2 = i - 1 - prex2;
                        if (prex1 < 0 || prex1 >= n || prey1 < 0 || prey1 >= n || prex2 < 0 || prex2 >= n || prey2 < 0 || prey2 >= n) {
                            continue;
                        }
                        if (grid[prex1][prey1] == -1 || grid[prex2][prey2] == -1) {
                            continue;
                        }
                        tmp = max(tmp, dp[i - 1][prex1][prex2]);
                    }
                    if (x1 == x2) {
                        dp[i][x1][x2] = max(dp[i][x1][x2], tmp + grid[x1][i - x1]);
                    } else {
                        dp[i][x1][x2] = max(dp[i][x1][x2], tmp + grid[x1][i - x1] + grid[x2][i - x2]);
                    }
                }
            }
        }
        return max(dp[2 * n - 2][n - 1][n - 1], 0);
    }
};
```