Cherry Pickup - Practice Coding Problems

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

Understanding the Visualization

Problem Transformation

Convert 'go down and come back up' into 'two robots go down together'

3D State Space

Track dp[steps][robot1_row][robot2_row] for all possible states

Movement Simulation

Each robot can move right or down, giving 4 possible combinations per step

Cherry Logic

If robots are at the same position, count cherry once; otherwise count both

Key Takeaway

🎯 Key Insight: Transform the problem from 'one robot round-trip' to 'two robots one-way journey' - this eliminates path dependencies and enables efficient dynamic programming!

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

Approach	Time	Space	Notes
✓ 3D Dynamic Programming (Optimal)	O(n³)	O(n³)	Model as two robots moving simultaneously using 3D DP to avoid double-counting
Brute Force (Try All Paths)	O(4^n)	O(n²)	Recursively try all possible down-then-up 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) {
        return grid[r1][c1];
    }
    
    if (dp[step][r1][r2] != -1) {
        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)

⚠ Quadratic 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