LeetCode 741. Cherry Pickup

题意

一个迷宫，从左上走到右下，走两次，最多能收集多少个1

题解

$dp[i][j][k][l]$ 表示两次分别走到$(i,j)$和$(k,l)$时的最大值，那么两个分别向前走就行了，四种情况。

补充一下 $i +j$ 其实是等于$k + l$ 的，所以其实三维就好了$dp[i][j][sum]$表示两次分别走到$(i,sum-i)$和$(j,sum-j)$时的最大值，代码就不写了。

#define MAXN 55
int dp[MAXN][MAXN][MAXN][MAXN];
class Solution {
public:
    int cherryPickup(vector<vector<int>>& grid) {
        memset(dp, -1, sizeof(dp));
        dp[0][0][0][0] = grid[0][0];
        int sz = grid.size();
        for (int i = 0; i < grid.size(); i++) {
            for (int j = 0; j < grid[0].size(); j++) {
                for (int k = 0; k < grid.size(); k++) {
                    for (int l = 0; l < grid[0].size(); l++) {
                        if (dp[i][j][k][l] == -1) {
                            continue;
                        }
                        if (i + 1 < sz && k + 1 < sz && grid[i + 1][j] != -1 && grid[k + 1][l] != -1) {
                            if (i + 1 == k + 1 && j == l) {
                                dp[i + 1][j][k + 1][l] = max(dp[i + 1][j][k + 1][l], dp[i][j][k][l] + grid[i + 1][j]);
                            }
                            else {
                                dp[i + 1][j][k + 1][l] = max(dp[i + 1][j][k + 1][l], dp[i][j][k][l] + grid[i + 1][j] + grid[k + 1][l]);
                            }
                        }
                        if (i + 1 < sz && l + 1 < sz && grid[i + 1][j] != -1 && grid[k][l + 1] != -1) {
                            if (i + 1 == k && j == l + 1) {
                                dp[i + 1][j][k][l + 1] = max(dp[i + 1][j][k][l + 1], dp[i][j][k][l] + grid[i + 1][j]);
                            }
                            else {
                                dp[i + 1][j][k][l + 1] = max(dp[i + 1][j][k][l + 1], dp[i][j][k][l] + grid[i + 1][j] + grid[k][l + 1]);
                            }
                        }
                        if (j + 1 < sz && l + 1 < sz && grid[i][j + 1] != -1 && grid[k][l + 1] != -1) {
                            if (i == k && j + 1 == l + 1) {
                                dp[i][j + 1][k][l + 1] = max(dp[i][j + 1][k][l + 1], dp[i][j][k][l] + grid[i][j + 1]);
                            }
                            else {
                                dp[i][j + 1][k][l + 1] = max(dp[i][j + 1][k][l + 1], dp[i][j][k][l] + grid[i][j + 1] + grid[k][l + 1]);
                            }
                        }
                        if (j + 1 < sz && k + 1 < sz && grid[i][j + 1] != -1 && grid[k + 1][l] != -1) {
                            if (i == k + 1 && j + 1 == l) {
                                dp[i][j + 1][k + 1][l] = max(dp[i][j + 1][k + 1][l], dp[i][j][k][l] + grid[i][j + 1]);
                            }
                            else {
                                dp[i][j + 1][k + 1][l] = max(dp[i][j + 1][k + 1][l], dp[i][j][k][l] + grid[i][j + 1] + grid[k + 1][l]);
                            }
                        }
                    }
                }
            }
        }
        int ans = dp[sz - 1][sz - 1][sz - 1][sz - 1];
        return ans == -1 ? 0 : ans;
    }

};