README_EN.md

741. Cherry Pickup

中文文档

Description

You are given an n x n grid representing a field of cherries, each cell is one of three possible integers.

• 0 means the cell is empty, so you can pass through,
• 1 means the cell contains a cherry that you can pick up and pass through, or
• -1 means the cell contains a thorn that blocks your way.

Return the maximum number of cherries you can collect by following the rules below:

• Starting at the position (0, 0) and reaching (n - 1, n - 1) by moving right or down through valid path cells (cells with value 0 or 1).
• After reaching (n - 1, n - 1), returning to (0, 0) by moving left or up through valid path cells.
• When passing through a path cell containing a cherry, you pick it up, and the cell becomes an empty cell 0.
• If there is no valid path between (0, 0) and (n - 1, n - 1), then no cherries can be collected.

 

Example 1:

Input: grid = [[0,1,-1],[1,0,-1],[1,1,1]]
Output: 5
Explanation: The player started at (0, 0) and went down, down, right right to reach (2, 2).
4 cherries were picked up during this single trip, and the matrix becomes [[0,1,-1],[0,0,-1],[0,0,0]].
Then, the player went left, up, up, left to return home, picking up one more cherry.
The total number of cherries picked up is 5, and this is the maximum possible.

Example 2:

Input: grid = [[1,1,-1],[1,-1,1],[-1,1,1]]
Output: 0

 

Constraints:

• n == grid.length
• n == grid[i].length
• 1 <= n <= 50
• grid[i][j] is -1, 0, or 1.
• grid[0][0] != -1
• grid[n - 1][n - 1] != -1

Solutions

Dynamic programming.

Python3

class Solution:
    def cherryPickup(self, grid: List[List[int]]) -> int:
        n = len(grid)
        dp = [[[float('-inf')] * n for _ in range(n)] for _ in range((n << 1) -1 )]
        dp[0][0][0] = grid[0][0]
        for k in range(1, (n << 1) - 1):
            for i1 in range(n):
                for i2 in range(n):
                    j1, j2 = k - i1, k - i2
                    if j1 >= 0 and j1 < n and j2 >= 0 and j2 < n:
                        if grid[i1][j1] == -1 or grid[i2][j2] == -1:
                            continue
                        t = grid[i1][j1]
                        if i1 != i2:
                            t += grid[i2][j2]
                        for p1 in range(i1 - 1, i1 + 1):
                            for p2 in range(i2 - 1, i2 + 1):
                                if p1 >= 0 and p2 >= 0:
                                    dp[k][i1][i2] = max(dp[k][i1][i2], dp[k - 1][p1][p2] + t)
        return max(dp[-1][-1][-1], 0)

Java

class Solution {
    public int cherryPickup(int[][] grid) {
        int n = grid.length;
        int[][][] dp = new int[2 * n][n][n];
        for (int[][] item : dp) {
            for (int[] row : item) {
                Arrays.fill(row, Integer.MIN_VALUE);
            }
        }
        dp[0][0][0] = grid[0][0];
        for (int k = 1; k < 2 * n - 1; ++k) {
            for (int i1 = 0; i1 < n; ++i1) {
                for (int i2 = 0; i2 < n; ++i2) {
                    int j1 = k - i1, j2 = k - i2;
                    if (j1 >= 0 && j1 < n && j2 >= 0 && j2 < n) {
                        if (grid[i1][j1] == -1 || grid[i2][j2] == -1) {
                            continue;
                        }
                        int t = grid[i1][j1];
                        if (i1 != i2) {
                            t += grid[i2][j2];
                        }
                        for (int p1 = i1 - 1; p1 <= i1; ++p1) {
                            for (int p2 = i2 - 1; p2 <= i2; ++p2) {
                                if (p1 >= 0 && p2 >= 0) {
                                    dp[k][i1][i2] = Math.max(dp[k][i1][i2], dp[k - 1][p1][p2] + t);
                                }
                            }
                        }
                    }   
                }
            }
        }
        return Math.max(dp[2 * n - 2][n - 1][n - 1], 0);
    }
}

C++

class Solution {
public:
    int cherryPickup(vector<vector<int>>& grid) {
        int n = grid.size();
        vector<vector<vector<int>>> dp(n << 1, vector<vector<int>>(n, vector<int>(n, -1e9)));
        dp[0][0][0] = grid[0][0];
        for (int k = 1; k < 2 * n - 1; ++k)
        {
            for (int i1 = 0; i1 < n; ++i1)
            {
                for (int i2 = 0; i2 < n; ++i2)
                {
                    int j1 = k - i1, j2 = k - i2;
                    if (j1 >= 0 && j1 < n && j2 >= 0 && j2 < n)
                    {
                        if (grid[i1][j1] == -1 || grid[i2][j2] == -1) continue;
                        int t = grid[i1][j1];
                        if (i1 != i2) t += grid[i2][j2];
                        for (int p1 = i1 - 1; p1 <= i1; ++p1)
                        {
                            for (int p2 = i2 - 1; p2 <= i2; ++p2)
                            {
                                if (p1 >= 0 && p2 >= 0) dp[k][i1][i2] = max(dp[k][i1][i2], dp[k - 1][p1][p2] + t);
                            }
                        }
                    }
                }
            }
        }
        return max(dp[2 * n - 2][n - 1][n - 1], 0);
    }
};

Go

func cherryPickup(grid [][]int) int {
    n := len(grid)
    dp := make([][][]int, (n << 1) - 1)
    for i := range dp {
        dp[i] = make([][]int, n)
        for j := range dp[i] {
            dp[i][j] = make([]int, n)
            for k := range dp[i][j] {
                dp[i][j][k] = int(-1e9)
            }
        }
    }
    dp[0][0][0] = grid[0][0]
    for k := 1; k < (n << 1) - 1; k++ {
        for i1 := 0; i1 < n; i1++ {
            for i2 := 0; i2 < n; i2++ {
                j1, j2 := k - i1, k - i2
                if j1 >= 0 && j1 < n && j2 >= 0 && j2 < n {
                    if grid[i1][j1] == -1 || grid[i2][j2] == -1 {
                        continue
                    }
                    t := grid[i1][j1]
                    if i1 != i2 {
                        t += grid[i2][j2]
                    }
                    for p1 := i1 - 1; p1 <= i1; p1++ {
                        for p2 := i2 - 1; p2 <= i2; p2++ {
                            if p1 >= 0 && p2 >= 0 {
                                dp[k][i1][i2] = max(dp[k][i1][i2], dp[k - 1][p1][p2] + t)
                            }
                        }
                    }
                }
            }
        }
    }

    return max(dp[(n << 1) - 2][n - 1][n - 1], 0)
}

func max(a, b int) int {
    if a > b {
        return a
    }
    return b
}

...