动态规划+四维数组降维+滚动数组降维 741. 摘樱桃

741. 摘樱桃

一个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颗樱桃，这是可以摘到的最大值了。

说明:

grid 是一个 N * N 的二维数组，N的取值范围是1 <= N <= 50。
每一个 grid[i][j] 都是集合 {-1, 0, 1}其中的一个数。
可以保证起点 grid[0][0] 和终点 grid[N-1][N-1] 的值都不会是 -1。

解题

来回能采摘的最大樱桃数=两人同时行动能采摘的最大樱桃数！

故思路为建立四维数组dp[i][j][m][n]，第一个人在ij，第二个人在mn；
若ij==mn，则加一次当前樱桃数；
若ij！=mn，则找到上一步的最大樱桃数+当前两人新一步采摘的樱桃数；

四维数组（超时代码）
初始化边界为INT_MIN，防止数组越界；

class Solution {
public:
    int cherryPickup(vector<vector<int>>& grid) {
        int n=grid.size();
        if(!n) return 0;
        vector<vector<vector<vector<int>>>> dp(n+1,vector<vector<vector<int>>>(n+1,vector<vector<int>>(n+1,vector<int>(n+1,INT_MIN))));
        dp[1][1][1][1]=grid[0][0];
        for(int i=1;i<=n;i++)
            for(int j=1;j<=n;j++)
                for(int t=1;t<=n;t++)
                    for(int k=1;k<=n;k++)
                    {
                        if(i==j==t==k==1) continue;
                        if(grid[i-1][j-1]==-1||grid[t-1][k-1]==-1)
                            continue;
                        if(i==t&&j==k)dp[i][j][t][k]=max({dp[i][j-1][t][k-1],dp[i][j-1][t-1][k],dp[i-1][j][t-1][k],dp[i-1][j][t][k-1]}) +grid[i-1][j-1];
                        else dp[i][j][t][k]=max({dp[i][j-1][t][k-1],dp[i][j-1][t-1][k],dp[i-1][j][t-1][k],dp[i-1][j][t][k-1]}) +grid[i-1][j-1]+grid[t-1][k-1];
                    }
        return max(0,dp[n][n][n][n]);
    }
};

降维1:用i1，i2，j1表示j2；

——第四个点可以由前三个点确定
因为两者同时出发，故i1+j1=i2+j2=k;
i1,i2,j1即可表示所有点；
j2=j1+i1-i2;

dp[i1][i2][j1]；
递推的四个方向为dp[i1-1][i2][j1]，dp[i1-1][i2-1][j1]，dp[i1][i2-1][j1-1]，dp[i1][i2][j1-1]；(满足i1，j1不同时减，i2，j2不同时减)；

i1取值为0～n；
i2取值为i1～n； （要保证j2=j1+i1-i2>0，因为j>i2-i1，所以i2-i1>0）；
j1取值为i2-i1~n；（要保证j2=j1+i1-i2>0，即j1>i2-i1）；

class Solution {
public:
    int cherryPickup(vector<vector<int>>& grid) {
        int n=grid.size();
        if(!n) return 0;

        vector<vector<vector<int>>> dp(n+1,vector<vector<int>>(n+1,vector<int>(n+1,INT_MIN)));
        dp[1][1][1]=grid[0][0];
        for(int i1=1;i1<=n;i1++)
            for(int i2=i1;i2<=n;i2++)
                for(int t=i2-i1+1;t<=n;t++)
                    {
                        int t2=i1+t-i2;
                        if(i1==i2&&i1==t&&t==1) continue;  //不能连等
                        if(grid[i1-1][t-1]==-1||grid[i2-1][t2-1]==-1)
                            continue;
                        if(i1==i2&&t==t2) dp[i1][i2][t]=max({dp[i1][i2-1][t-1],dp[i1-1][i2-1][t],dp[i1-1][i2][t],dp[i1][i2][t-1]})+grid[i1-1][t-1];
                        else dp[i1][i2][t]=max({dp[i1][i2-1][t-1],dp[i1-1][i2-1][t],dp[i1-1][i2][t],dp[i1][i2][t-1]}) +grid[i1-1][t-1]+grid[i2-1][t2-1];
                    }
        return max(0,dp[n][n][n]);
    }
};

注意点
不能连续==；
下标从1开始，防止数组越界；

降维2:用i1，i2，和t=i1+j1=i2+j2表示j1，j2；

j1=t-i1;
j2=t-i2;

t取值范围——0～2*n；
i1取值范围——max(t-n,1)～min(t-1,n)；（要保证j1，i1，t都大于0）；
i2取值范围——i1～min(t-1,n)；

class Solution {
public:
    int cherryPickup(vector<vector<int>>& grid) {
        int n=grid.size();
        if(!n) return 0;

        vector<vector<vector<int>>> dp(n+1,vector<vector<int>>(n+1,vector<int>(2*n+1,INT_MIN)));
        dp[1][1][2]=grid[0][0];
        for(int t=3;t<=2*n;t++)   //t=i1+j1=i2+j2
            for(int i1=max(t-n,1);i1<=min(t-1,n);i1++)
                for(int i2=i1;i2<=min(t-1,n);i2++)
                    {
                        int j1=t-i1;
                        int j2=t-i2;
                        //if(i1==i2&&i1==1&&t==2) continue; 
                        if(grid[i1-1][j1-1]==-1||grid[i2-1][j2-1]==-1)  continue;
                        if(i1==i2&&j1==j2) dp[i1][i2][t]=max({dp[i1][i2-1][t-1],dp[i1-1][i2-1][t-1],dp[i1-1][i2][t-1],dp[i1][i2][t-1]})+grid[i1-1][j1-1];
                        else dp[i1][i2][t]=max({dp[i1][i2-1][t-1],dp[i1-1][i2-1][t-1],dp[i1-1][i2][t-1],dp[i1][i2][t-1]}) +grid[i1-1][j1-1]+grid[i2-1][j2-1];
                    }
        return max(0,dp[n][n][2*n]);
    }
};

滚动数组再次降维
上述t都由t-1递推而得，故可在二维数组上滚动递推。

class Solution {
public:
    int cherryPickup(vector<vector<int>>& grid) {
        int N = grid.size(), dp[N+1][N+1];
        memset(dp, 0x80, sizeof(dp)); //-2139062144, 作用相当于 INT_MIN
        dp[N-1][N-1] = grid[N-1][N-1]; // 初始边界条件
        for(int sum = 2*N - 3; sum >= 0; --sum)
        for(int i1 = max(0, sum - N + 1); i1 <= min(N-1,sum); ++i1)
        for(int i2 = i1; i2 <= min(N-1,sum); ++i2)
        {
            int j1 = sum - i1, j2 = sum - i2;
            if(grid[i1][j1] == -1 || grid[i2][j2] == -1) 
                dp[i1][i2] = INT_MIN;
            else
                dp[i1][i2] = grid[i1][j1] + (i1 != i2 || j1 != j2)*grid[i2][j2] + max(
                    max(dp[i1][i2+1], dp[i1+1][i2]), 
                    max(dp[i1+1][i2+1], dp[i1][i2])
                );
        }
        return max(0, dp[0][0]);     
    }
};

倒序递推；