1、题目描述

2、题解：

动态规划：

参考 C++代码：

class Solution {
          
   
public:
    int cherryPickup(vector<vector<int>>& grid) {
          
   
        // 动态规划
        int n = grid.size(),dp[n + 1][n + 1];
        memset(dp,0x80,sizeof(dp));
        dp[n - 1][n -1] = grid[n - 1][n - 1];
        for (int t = 2 * n - 3;t >= 0;--t)
            for (int i1 = max(0,t - n + 1);i1 <= min(n - 1,t);++i1)
                for (int i2 = i1;i2 <= min(n - 1,t);++i2){
          
   
                    int j1 = t - i1,j2 = t - 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]);
    }
};

Python代码：

class Solution:
    def cherryPickup(self, grid: List[List[int]]) -> int:
        #动态规划
        n = len(grid)
        dp = [[float(-inf)] * n for _ in range(n)]
        dp[0][0] = grid[0][0]
        for t in range(1,2 * n - 1):
            dp2 = [[float(-inf)] * n for _ in range(n)]
            for i in range(max(0,t - (n - 1)),min(n - 1,t) + 1):
                for j in range(max(0,t - (n - 1)), min(n - 1,t) + 1):
                    if grid[i][t - i] == -1 or grid[j][t - j] == -1:
                        continue 
                    val = grid[i][t - i]
                    if i != j:val += grid[j][t - j]
                    dp2[i][j] = max(dp[pi][pj] + val for pi in (i - 1,i) for pj in (j - 1,j) if pi >= 0 and pj >= 0)
            dp = dp2 
        return max(0,dp[n - 1][n - 1])

或者自顶而下的写法：

class Solution:
    def cherryPickup(self, grid: List[List[int]]) -> int:
        #动态规划，自顶而下
        n = len(grid)
        memo = [[[None] * n for _1 in range(n)] for _2 in range(n)]
        def dp(r1,c1,c2):
            r2 = r1 + c1 - c2 
            if (n == r1 or n == r2 or n == c1 or n == c2 or grid[r1][c1] == -1 or grid[r2][c2] == -1):
                return float(-inf)
            elif r1 == c1 == n - 1:
                return grid[r1][c1]
            elif memo[r1][c1][c2] is not None:
                return memo[r1][c1][c2]
            else:
                res = grid[r1][c1] + (c1 != c2) * grid[r2][c2] 
                res += max(dp(r1,c1 + 1,c2),dp(r1,c1 + 1,c2 + 1),dp(r1 + 1,c1,c2),dp(r1 + 1,c1,c2 + 1))
            memo[r1][c1][c2] = res 
            return res 
        return max(0,dp(0,0,0))

3、复杂度分析：