Watch 10 video solutions for Find the Maximum Number of Fruits Collected, a hard level problem involving Array, Dynamic Programming, Matrix. This walkthrough by codestorywithMIK has 9,839 views views. Want to try solving it yourself? Practice on FleetCode or read the detailed text solution.
There is a game dungeon comprised of n x n rooms arranged in a grid.
You are given a 2D array fruits of size n x n, where fruits[i][j] represents the number of fruits in the room (i, j). Three children will play in the game dungeon, with initial positions at the corner rooms (0, 0), (0, n - 1), and (n - 1, 0).
The children will make exactly n - 1 moves according to the following rules to reach the room (n - 1, n - 1):
(0, 0) must move from their current room (i, j) to one of the rooms (i + 1, j + 1), (i + 1, j), and (i, j + 1) if the target room exists.(0, n - 1) must move from their current room (i, j) to one of the rooms (i + 1, j - 1), (i + 1, j), and (i + 1, j + 1) if the target room exists.(n - 1, 0) must move from their current room (i, j) to one of the rooms (i - 1, j + 1), (i, j + 1), and (i + 1, j + 1) if the target room exists.When a child enters a room, they will collect all the fruits there. If two or more children enter the same room, only one child will collect the fruits, and the room will be emptied after they leave.
Return the maximum number of fruits the children can collect from the dungeon.
Example 1:
Input: fruits = [[1,2,3,4],[5,6,8,7],[9,10,11,12],[13,14,15,16]]
Output: 100
Explanation:

In this example:
(0,0) -> (1,1) -> (2,2) -> (3, 3).(0,3) -> (1,2) -> (2,3) -> (3, 3).(3,0) -> (3,1) -> (3,2) -> (3, 3).In total they collect 1 + 6 + 11 + 16 + 4 + 8 + 12 + 13 + 14 + 15 = 100 fruits.
Example 2:
Input: fruits = [[1,1],[1,1]]
Output: 4
Explanation:
In this example:
(0,0) -> (1,1).(0,1) -> (1,1).(1,0) -> (1,1).In total they collect 1 + 1 + 1 + 1 = 4 fruits.
Constraints:
2 <= n == fruits.length == fruits[i].length <= 10000 <= fruits[i][j] <= 1000Problem Overview: You are given a matrix where each cell contains a certain number of fruits. Multiple collectors move through the grid simultaneously and gather fruits along their paths. When two collectors land on the same cell, the fruit should only be counted once. The goal is to compute the maximum total fruits that can be collected following the allowed movements.
Approach 1: Recursive DFS with Memoization (Time: O(m * n^2), Space: O(m * n^2))
This approach models the problem as a recursive search where the state represents the row index and the column positions of the collectors. At each step, both collectors move to the next row with possible column shifts (left, stay, right). The recursive function explores all combinations of moves and collects fruits from the current cells. A memoization table caches results for states like (row, col1, col2) so the same subproblem is not recomputed. This drastically reduces exponential branching to polynomial complexity. DFS with memoization is intuitive when you first reason about the transitions and want a clear top‑down formulation.
Approach 2: Dynamic Programming with Three-Dimensional DP Array (Time: O(m * n^2), Space: O(m * n^2))
The optimal approach converts the recursive idea into bottom‑up dynamic programming. Define dp[row][c1][c2] as the maximum fruits collected when both collectors are on row row at columns c1 and c2. For every state, iterate through the nine possible column transitions for the next row (each collector can move left, stay, or right). Add fruits from the current cells, making sure not to double count when c1 == c2. The DP table is filled row by row until the last row is processed. This eliminates recursion overhead and gives a predictable iteration pattern, which performs well in practice for large grids.
Both approaches rely on the same insight: the future result depends only on the current row and the column positions of both collectors. That makes the problem a classic multi‑agent grid DP similar to problems in Dynamic Programming on a Matrix. The DP state captures both positions simultaneously, which is why a three‑dimensional structure is required.
Recommended for interviews: The three‑dimensional DP solution is what interviewers usually expect. Start by describing the recursive state and transitions, then convert it to a bottom‑up DP table. Mentioning the memoized DFS first shows you understand the problem decomposition, while presenting the iterative DP demonstrates strong command of Array and grid dynamic programming techniques.
| Approach | Time | Space | When to Use |
|---|---|---|---|
| Recursive DFS with Memoization | O(m * n^2) | O(m * n^2) | Good for understanding the state transitions and building the solution top‑down |
| 3D Dynamic Programming (Bottom‑Up) | O(m * n^2) | O(m * n^2) | Best practical solution with iterative DP and no recursion overhead |