Cherry Pickup II

Cherry Pickup II - Problem

Imagine you're managing a cherry orchard with two advanced harvesting robots! 🤖🍒

You have a rows × cols grid representing a cherry field where grid[i][j] contains the number of cherries at position (i, j).

The Setup:

🤖 Robot #1 starts at the top-left corner (0, 0)
🤖 Robot #2 starts at the top-right corner (0, cols-1)

Movement Rules:

From cell (i, j), robots can move to: (i+1, j-1), (i+1, j), or (i+1, j+1)
When a robot passes through a cell, it collects all cherries and the cell becomes empty
If both robots visit the same cell, only one robot gets the cherries
Both robots must reach the bottom row

Goal: Find the maximum number of cherries both robots can collect together!

Input & Output

example_1.py — Basic Case

$ Input: grid = [[3,1,1],[2,5,1],[1,5,5],[2,1,1]]

› Output: 24

💡 Note: Robot 1: (0,0)→(1,1)→(2,1)→(3,1) collecting 3+5+5+1=14 cherries. Robot 2: (0,2)→(1,1)→(2,2)→(3,1) but cell (1,1) already visited by Robot 1, so collects 1+0+5+0=6 cherries. Wait, that's wrong! Both robots move simultaneously, so at (1,1) they collect 5 cherries once. Optimal path: Robot1: (0,0)→(1,0)→(2,1)→(3,1) = 3+2+5+1=11. Robot2: (0,2)→(1,1)→(2,2)→(3,1) = 1+5+5+0=11 (but (3,1) shared). Total: 3+2+1+5+5+5+1 = 22. Actually, optimal is 24 with different paths.

example_2.py — Small Grid

$ Input: grid = [[1,0,0,0,0,0,1],[2,0,0,0,0,3,0],[2,0,9,0,0,0,0],[0,3,0,5,4,0,0],[1,0,2,3,0,0,6]]

› Output: 28

💡 Note: Robots start at (0,0) and (0,6). They need to collect maximum cherries while moving down. The large 9 in the middle and strategic positioning allows for optimal collection of 28 cherries total.

example_3.py — Edge Case - Single Row

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

› Output: 2

💡 Note: With only one row, Robot 1 starts at position 0 (collects 1 cherry) and Robot 2 starts at position 19 (collects 1 cherry). Total = 2 cherries since they can't move anywhere.

Constraints

rows == grid.length
cols == grid[i].length
2 ≤ rows, cols ≤ 70
0 ≤ grid[i][j] ≤ 100
Both robots must reach the bottom row

Visualization

Tap to expand

Asked in

G Google 45 a Amazon 38 f Facebook 31 ⊞ Microsoft 22

The optimal solution uses 3D Dynamic Programming with memoization. Key insight: since both robots move down simultaneously, we can represent the state as (row, col1, col2) and store the maximum cherries collectible from each state. Time complexity: O(rows × cols²), avoiding the exponential brute force approach.

Common Approaches

✓ Optimized

⏱️ Time: N/A Space: N/A

Two Pointers

⏱️ Time: N/A Space: N/A

3D Dynamic Programming (Optimal)

⏱️ Time: O(rows × cols²) Space: O(rows × cols²)

Since both robots move down simultaneously, we can represent the state as (row, col1, col2). Use dynamic programming to store the maximum cherries collectible from each state, avoiding redundant calculations.

Brute Force Recursion

⏱️ Time: O(3^(2×rows)) Space: O(rows)

Generate all possible paths for both robots simultaneously and pick the combination that yields maximum cherries. Each robot has 3 choices at each step, leading to exponential combinations.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

int nextIndex(int* nums, int numsSize, int i) {
    return (i + nums[i] % numsSize + numsSize) % numsSize;
}

bool solution(int* nums, int numsSize) {
    bool* visited = (bool*)calloc(numsSize, sizeof(bool));
    
    for (int i = 0; i < numsSize; i++) {
        if (visited[i] || nums[i] == 0) continue;
        
        // Use slow and fast pointers for this path
        int slow = i, fast = i;
        bool forward = nums[i] > 0;
        
        // Check if we can form a valid cycle
        while ((nums[slow] > 0) == forward && 
               (nums[fast] > 0) == forward && 
               (nums[nextIndex(nums, numsSize, fast)] > 0) == forward) {
            slow = nextIndex(nums, numsSize, slow);
            fast = nextIndex(nums, numsSize, nextIndex(nums, numsSize, fast));
            
            if (slow == fast) {
                // Found potential cycle, check if length > 1
                if (slow == nextIndex(nums, numsSize, slow)) break; // Self loop
                
                // Verify entire cycle has same direction
                int curr = slow;
                bool validCycle = true;
                while (1) {
                    if ((nums[curr] > 0) != forward) {
                        validCycle = false;
                        break;
                    }
                    curr = nextIndex(nums, numsSize, curr);
                    if (curr == slow) break;
                }
                
                if (validCycle) {
                    free(visited);
                    return true;
                }
                break;
            }
        }
        
        // Mark all nodes in this path as visited
        int curr = i;
        while (!visited[curr] && (nums[curr] > 0) == forward) {
            visited[curr] = true;
            curr = nextIndex(nums, numsSize, curr);
        }
    }
    
    free(visited);
    return false;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array manually
    int nums[1000];
    int numsSize = 0;
    
    char* ptr = strchr(line, '[');
    if (ptr == NULL) return 0;
    ptr++;
    
    if (*ptr == ']') {
        printf("false\n");
        return 0;
    }
    
    char* token = strtok(ptr, ",]");
    while (token != NULL) {
        nums[numsSize++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    bool result = solution(nums, numsSize);
    printf(result ? "true\n" : "false\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

89.0K Views

Medium Frequency

~25 min Avg. Time

2.9K 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