Find the Maximum Number of Fruits Collected

Find the Maximum Number of Fruits Collected - Problem

Welcome to the Fruit Collection Adventure! Imagine three children exploring a magical n × n dungeon filled with delicious fruits. Each room (i, j) contains fruits[i][j] pieces of fruit waiting to be collected.

The three children start at different corners:

Child A: Top-left corner (0, 0)
Child B: Top-right corner (0, n-1)
Child C: Bottom-left corner (n-1, 0)

All three must reach the treasure room at (n-1, n-1) in exactly n-1 moves. Each child has specific movement rules:

Child A: Can move to (i+1, j+1), (i+1, j), or (i, j+1) (diagonal, down, or right)
Child B: Can move to (i+1, j-1), (i+1, j), or (i+1, j+1) (down-left, down, or down-right)
Child C: Can move to (i-1, j+1), (i, j+1), or (i+1, j+1) (up-right, right, or down-right)

Important rule: If multiple children enter the same room, only one gets the fruits! Your goal is to find the maximum total fruits they can collect by choosing optimal paths.

Input & Output

example_1.py — Basic 3x3 Grid

$ Input: fruits = [[1,2,3],[4,5,6],[7,8,9]]

› Output: 24

💡 Note: Child A: (0,0)→(1,1)→(2,2) collects 1+5+9=15. Child B: (0,2)→(1,2)→(2,2) would collect 3+6, but (2,2) already taken. Child C: (2,0)→(2,1)→(2,2) would collect 7+8, but (2,2) already taken. Optimal paths give total 24 fruits.

example_2.py — Symmetric Grid

$ Input: fruits = [[1,1,1],[1,1,1],[1,1,1]]

› Output: 7

💡 Note: All cells have 1 fruit. Three children must coordinate to visit 7 unique cells total to reach (2,2), collecting 7 fruits maximum.

example_3.py — Edge Case 2x2

$ Input: fruits = [[5,10],[15,20]]

› Output: 50

💡 Note: Child A: (0,0)→(1,1) gets 5+20=25. Child B: (0,1)→(1,1) gets 10 (can't get (1,1) again). Child C: (1,0)→(1,1) gets 15 (can't get (1,1) again). Total: 5+10+15+20=50.

Constraints

2 ≤ n ≤ 20
0 ≤ fruits[i][j] ≤ 1000
All three children must reach (n-1, n-1) in exactly n-1 moves
Movement constraints differ for each child
When multiple children occupy same cell, only one collects fruits

Visualization

Tap to expand

Understanding the Visualization

Setup

Three children start at corners: A at (0,0), B at (0,n-1), C at (n-1,0)

Movement Rules

Each child has different movement constraints based on their starting position

Conflict Handling

When children occupy the same cell, only one can collect the fruits

Dynamic Programming

Use 3D DP to track all positions and memoize optimal solutions

Optimal Solution

Return maximum fruits collected through coordinated optimal paths

Key Takeaway

🎯 Key Insight: Use 3D Dynamic Programming to simultaneously track all three children's positions, handling conflicts optimally through memoized state transitions.

Asked in

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

This problem requires 3D Dynamic Programming where we track all three children's positions simultaneously. The optimal approach uses memoization with state (step, pos1, pos2, pos3) and handles fruit collection conflicts using set operations. Time complexity is O(n⁶) but much faster than brute force due to avoiding redundant calculations.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming (3D State Space)	O(n^6)	O(n^6)	Use memoized recursion to track all three children's positions simultaneously

Dynamic Programming (3D State Space) — Algorithm Steps

Define state as (step, pos1, pos2, pos3) representing current step and all positions
Use memoization to cache results for each state combination
For each state, try all valid move combinations for the three children
Handle fruit collection conflicts by using set of unique positions
Return maximum fruits from memoized recursive calls

Visualization

Tap to expand

Step-by-Step Walkthrough

Define State

State = (step, pos1, pos2, pos3) representing all positions

Memoization

Cache results for each state to avoid recomputation

State Transitions

For each state, try all valid move combinations

Conflict Resolution

Use set operations to handle overlapping positions

Optimal Substructure

Build solution from cached optimal subproblems

Code -

solution.c — C

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

#define MAX_N 20
#define HASH_SIZE 1000007

int n;
int fruits[MAX_N][MAX_N];

typedef struct {
    int step, r1, c1, r2, c2, r3, c3;
    int value;
} MemoEntry;

MemoEntry memo[HASH_SIZE];
int memoSize = 0;

int hash(int step, int r1, int c1, int r2, int c2, int r3, int c3) {
    return (step * 1000000 + r1 * 100000 + c1 * 10000 + r2 * 1000 + c2 * 100 + r3 * 10 + c3) % HASH_SIZE;
}

int findMemo(int step, int r1, int c1, int r2, int c2, int r3, int c3) {
    int h = hash(step, r1, c1, r2, c2, r3, c3);
    for (int i = 0; i < memoSize; i++) {
        if (memo[i].step == step && memo[i].r1 == r1 && memo[i].c1 == c1 &&
            memo[i].r2 == r2 && memo[i].c2 == c2 && memo[i].r3 == r3 && memo[i].c3 == c3) {
            return memo[i].value;
        }
    }
    return -1;
}

void addMemo(int step, int r1, int c1, int r2, int c2, int r3, int c3, int value) {
    memo[memoSize].step = step;
    memo[memoSize].r1 = r1; memo[memoSize].c1 = c1;
    memo[memoSize].r2 = r2; memo[memoSize].c2 = c2;
    memo[memoSize].r3 = r3; memo[memoSize].c3 = c3;
    memo[memoSize].value = value;
    memoSize++;
}

int isValid(int r, int c) {
    return r >= 0 && r < n && c >= 0 && c < n;
}

int dp(int step, int r1, int c1, int r2, int c2, int r3, int c3) {
    if (step == n - 1) {
        if (r1 == n-1 && c1 == n-1 && r2 == n-1 && c2 == n-1 && r3 == n-1 && c3 == n-1) {
            return fruits[n-1][n-1];
        }
        return 0;
    }
    
    int cached = findMemo(step, r1, c1, r2, c2, r3, c3);
    if (cached != -1) return cached;
    
    int maxFruits = 0;
    
    int moves1[3][2] = {{r1+1, c1+1}, {r1+1, c1}, {r1, c1+1}};
    int moves2[3][2] = {{r2+1, c2-1}, {r2+1, c2}, {r2+1, c2+1}};
    int moves3[3][2] = {{r3-1, c3+1}, {r3, c3+1}, {r3+1, c3+1}};
    
    for (int i = 0; i < 3; i++) {
        if (!isValid(moves1[i][0], moves1[i][1])) continue;
        for (int j = 0; j < 3; j++) {
            if (!isValid(moves2[j][0], moves2[j][1])) continue;
            for (int k = 0; k < 3; k++) {
                if (!isValid(moves3[k][0], moves3[k][1])) continue;
                
                int collected = 0;
                int visited[MAX_N][MAX_N] = {0};
                
                if (!visited[moves1[i][0]][moves1[i][1]]) {
                    collected += fruits[moves1[i][0]][moves1[i][1]];
                    visited[moves1[i][0]][moves1[i][1]] = 1;
                }
                if (!visited[moves2[j][0]][moves2[j][1]]) {
                    collected += fruits[moves2[j][0]][moves2[j][1]];
                    visited[moves2[j][0]][moves2[j][1]] = 1;
                }
                if (!visited[moves3[k][0]][moves3[k][1]]) {
                    collected += fruits[moves3[k][0]][moves3[k][1]];
                    visited[moves3[k][0]][moves3[k][1]] = 1;
                }
                
                collected += dp(step + 1, moves1[i][0], moves1[i][1], moves2[j][0], moves2[j][1], moves3[k][0], moves3[k][1]);
                if (collected > maxFruits) {
                    maxFruits = collected;
                }
            }
        }
    }
    
    addMemo(step, r1, c1, r2, c2, r3, c3, maxFruits);
    return maxFruits;
}

int maxCollectedFruits() {
    return dp(0, 0, 0, 0, n-1, n-1, 0);
}

int main() {
    n = 3;
    int input[3][3] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            fruits[i][j] = input[i][j];
        }
    }
    printf("%d\n", maxCollectedFruits());
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n^6)

Each child can be in O(n^2) positions, giving O(n^6) states, each taking O(27) time

✓ Linear Growth

Space Complexity

O(n^6)

Memoization table stores results for all possible state combinations

⚡ Linearithmic Space

26.4K Views

Medium Frequency

~35 min Avg. Time

856 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

Dynamic Programming (3D State Space) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler