Cherry Pickup

Cherry Pickup - Problem

Cherry Pickup is a challenging path optimization problem that combines forward and backward traversal with dynamic programming.

You're given an n × n grid representing a cherry field where each cell contains:
• 0 - Empty cell (passable)
• 1 - Cherry (can pick up and pass through)
• -1 - Thorn (blocks your path)

Your mission:
1. Start at (0,0) and reach (n-1,n-1) by moving only right or down
2. Return from (n-1,n-1) to (0,0) by moving only left or up
3. Collect maximum cherries possible during both journeys
4. Once picked, cherries disappear (cell becomes 0)

Goal: Return the maximum number of cherries you can collect, or 0 if no valid path exists.

Input & Output

example_1.py — Basic Grid

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

› Output: 5

💡 Note: Path 1: (0,0)→(1,0)→(2,0)→(2,1)→(2,2) collects 3 cherries. Path 2: (2,2)→(2,1)→(2,0)→(1,0) would collect 2, but (1,0) cherry is gone, so only 1 more cherry from (2,1). Total: 4. Actually, optimal is 5 when modeled as two robots.

example_2.py — Single Cell

$ Input: grid = [[1]]

› Output: 1

💡 Note: Only one cell with one cherry. Robot goes there and back, collecting 1 cherry total.

example_3.py — Blocked Path

$ Input: grid = [[1,1,-1],[1,-1,1],[-1,1,1]]

› Output: 0

💡 Note: No valid path exists from (0,0) to (2,2) due to thorn blocks, so return 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

Visualization

Tap to expand

Asked in

G Google 42 a Amazon 35 f Meta 28 ⊞ Microsoft 22

The optimal solution uses 3D Dynamic Programming with a key insight: model the problem as two robots moving simultaneously from (0,0) to (n-1,n-1) instead of one robot going down and back up. This avoids path dependency issues and achieves O(n³) time complexity. The DP state dp[step][r1][r2] represents maximum cherries when both robots have taken 'step' moves with robot positions at rows r1 and r2.

Common Approaches

✓ 3D Dynamic Programming (Optimal)

⏱️ Time: O(n³) Space: O(n³)

The key insight is to think of the problem as two robots starting at (0,0) and moving simultaneously to (n-1,n-1), both only able to move right or down. This is mathematically equivalent to going down and coming back up, but avoids the complexity of path dependencies. We use 3D DP where dp[step][r1][r2] represents the maximum cherries when both robots have taken 'step' moves, robot1 is at row r1, and robot2 is at row r2.

Brute Force (Try All Paths)

⏱️ Time: O(4^n) Space: O(n²)

Generate all possible paths from (0,0) to (n-1,n-1), then for each valid path, generate all possible return paths and calculate cherry collection. This approach has exponential time complexity due to the vast number of path combinations.

3D Dynamic Programming (Optimal) — Algorithm Steps

Model the problem as two robots moving simultaneously from (0,0) to (n-1,n-1)
Use 3D DP: dp[step][r1][r2] = max cherries after 'step' moves with robots at rows r1 and r2
Column positions are determined by: c1 = step - r1, c2 = step - r2
For each state, try all 4 combinations of robot movements (right/down for each)
Handle cherry collection: add 1 if r1==r2 and cell has cherry, else add 2 if both cells have cherries
Return dp[2n-2][n-1][n-1] as the final answer

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Both robots start at (0,0), ready to move right or down

Simultaneous Movement

Each robot independently chooses to move right or down

Cherry Collection

If robots are at same position, collect 1 cherry; otherwise collect from both positions

Dynamic Programming

Memoize results for each (step, robot1_row, robot2_row) combination

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>

#define MAX_N 50

int n;
int grid[MAX_N][MAX_N];
int dp[2*MAX_N][MAX_N][MAX_N];

int solve(int step, int r1, int r2) {
    int c1 = step - r1;
    int c2 = step - r2;
    
    if (r1 >= n || r2 >= n || c1 >= n || c2 >= n ||
        grid[r1][c1] == -1 || grid[r2][c2] == -1) {
        return INT_MIN;
    }
    
    if (r1 == n - 1 && c1 == n - 1) {
        static return grid[r1][c1];
    }
    
    if (dp[step][r1][r2] != -1) {
        static return dp[step][r1][r2];
    }
    
    int cherries = 0;
    if (r1 == r2) {
        cherries = grid[r1][c1];
    } else {
        cherries = grid[r1][c1] + grid[r2][c2];
    }
    
    int result = INT_MIN;
    for (int dr1 = 0; dr1 <= 1; dr1++) {
        for (int dr2 = 0; dr2 <= 1; dr2++) {
            int subResult = solve(step + 1, r1 + dr1, r2 + dr2);
            if (subResult > result) {
                result = subResult;
            }
        }
    }
    
    cherries += result;
    dp[step][r1][r2] = cherries;
    return cherries;
}

int cherryPickup(int inputGrid[][MAX_N], int size) {
    n = size;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            grid[i][j] = inputGrid[i][j];
        }
    }
    
    memset(dp, -1, sizeof(dp));
    
    int result = solve(0, 0, 0);
    return result < 0 ? 0 : result;
}

int main() {
    int testGrid[3][MAX_N] = {{0, 1, -1}, {1, 0, -1}, {1, 1, 1}};
    printf("%d\n", cherryPickup(testGrid, 3));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Three nested loops: steps (2n), and two robot positions (n each)

✓ Linear Growth

Space Complexity

O(n³)

3D DP table with dimensions (2n) × n × n, can be optimized to O(n²)

⚠ Quadratic Space

52.0K Views

Medium-High Frequency

~25 min Avg. Time

1.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

3D Dynamic Programming (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler