Remove Boxes - Practice Coding Problems

Remove Boxes - Problem

Remove Boxes - Maximum Points Game

Imagine you have a row of colorful boxes, each represented by a positive number indicating its color. Your goal is to remove all boxes and maximize your score in the process!

Game Rules:
• You can remove any continuous sequence of boxes with the same color
• If you remove k consecutive boxes of the same color, you earn k × k points
• Continue until no boxes remain

Strategy Example: For boxes [1,3,2,2,2,3,4,3,1], you could remove the middle three 2's first (earning 3×3=9 points), which brings the 3's together for a potentially higher score later!

Return the maximum total points you can achieve with optimal play.

Input & Output

example_1.py — Basic Case

$ Input: [1,3,2,2,2,3,4,3,1]

› Output: 23

💡 Note: Remove middle three 2's first (3×3=9 points), then remove the two 3's together (2×2=4 points), then remove remaining boxes individually (1+1+1+1=4 points). Total: 9+4+4+1+1+1+1+1 = 23 points.

example_2.py — Simple Consecutive

$ Input: [1,1,1]

› Output: 9

💡 Note: Remove all three 1's at once to get 3×3 = 9 points. This is better than removing them separately (1+1+1 = 3 points).

example_3.py — Single Box

$ Input: [1]

› Output: 1

💡 Note: Only one box, so we remove it and get 1×1 = 1 point.

Constraints

1 ≤ boxes.length ≤ 100
1 ≤ boxes[i] ≤ 100
Each box color is represented by a positive integer
The array can contain duplicate colors in non-consecutive positions

Visualization

Tap to expand

Understanding the Visualization

Analyze the Array

Identify potential same-color groups that could be combined if middle elements are removed first

Strategic Removal

Instead of greedy removal, consider removing middle sections to bring same colors together

Dynamic Programming

Use 3D DP to track all possible states and find optimal removal sequence

Maximize Score

Choose the sequence that maximizes total points with k² scoring system

Key Takeaway

🎯 Key Insight: The optimal solution uses 3D dynamic programming to consider both immediate removal and strategic delayed removal. The third dimension k tracks potential future combinations, allowing the algorithm to make optimal decisions about when to remove boxes versus when to wait for better combos.

Asked in

G Google 42 a Amazon 28 f Meta 15 ⊞ Microsoft 12

The Remove Boxes problem requires 3D Dynamic Programming with memoization. The key insight is using state dp[i][j][k] representing maximum points from boxes[i..j] where we have k additional boxes of the same color as boxes[j] that can be combined later. This allows us to consider both immediate removal and strategic delayed removal to create larger same-colored groups worth exponentially more points.

Common Approaches

Approach	Time	Space	Notes
✓ Recursive Brute Force with Memoization	O(n⁴)	O(n³)	Use 3D dynamic programming with memoization to avoid recalculating subproblems

Recursive Brute Force with Memoization — Algorithm Steps

Define DP state: dp(i,j,k) = max points from boxes[i..j] with k extra boxes of color boxes[j]
Base case: if i > j, return 0 points
Option 1: Remove boxes[j] along with k extra boxes → (k+1)² + dp(i,j-1,0)
Option 2: Find boxes[m] where boxes[m] == boxes[j], combine them → dp(i,m,k+1) + dp(m+1,j-1,0)
Return maximum of all options

Visualization

Tap to expand

Step-by-Step Walkthrough

Define 3D State

dp[i][j][k] = max points from boxes[i..j] with k extra boxes of color boxes[j]

Two Choices

Either remove boxes[j] now, or find matching color to combine with

Merge Strategy

Look for boxes[m] == boxes[j] and recursively solve subproblems

Memoization

Cache results to avoid recalculating same subproblems

Code -

solution.c — C

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

#define MAX_N 100
#define MAX_KEY 50

typedef struct {
    char key[MAX_KEY];
    int value;
} MemoEntry;

MemoEntry memo[10000];
int memoSize = 0;

int findMemo(const char* key) {
    for (int i = 0; i < memoSize; i++) {
        if (strcmp(memo[i].key, key) == 0) {
            return memo[i].value;
        }
    }
    return -1;
}

void addMemo(const char* key, int value) {
    strcpy(memo[memoSize].key, key);
    memo[memoSize].value = value;
    memoSize++;
}

int dp(int* boxes, int i, int j, int k) {
    if (i > j) return 0;
    
    char key[MAX_KEY];
    sprintf(key, "%d,%d,%d", i, j, k);
    
    int cached = findMemo(key);
    if (cached != -1) {
        return cached;
    }
    
    // Optimize: merge consecutive same colors at the end
    while (j > i && boxes[j] == boxes[j-1]) {
        j--;
        k++;
    }
    
    // Option 1: remove boxes[j] along with k extra boxes
    int result = (k + 1) * (k + 1) + dp(boxes, i, j-1, 0);
    
    // Option 2: find boxes[m] where boxes[m] == boxes[j]
    for (int m = i; m < j; m++) {
        if (boxes[m] == boxes[j]) {
            int candidate = dp(boxes, i, m, k+1) + dp(boxes, m+1, j-1, 0);
            if (candidate > result) {
                result = candidate;
            }
        }
    }
    
    addMemo(key, result);
    return result;
}

int removeBoxes(int* boxes, int boxesSize) {
    memoSize = 0; // Reset memo
    if (boxesSize == 0) return 0;
    return dp(boxes, 0, boxesSize - 1, 0);
}

int main() {
    int boxes[MAX_N];
    int size = 0;
    
    char input[1000];
    fgets(input, sizeof(input), stdin);
    
    // Parse input format [1,2,3]
    char* ptr = strchr(input, '[');
    if (ptr) {
        ptr++; // Skip '['
        char* token = strtok(ptr, ",]");
        while (token && size < MAX_N) {
            boxes[size++] = atoi(token);
            token = strtok(NULL, ",]");
        }
    }
    
    printf("%d\n", removeBoxes(boxes, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n⁴)

Three nested loops for i,j,k plus inner loop to find matching colors, with memoization preventing redundant calculations

✓ Linear Growth

Space Complexity

O(n³)

3D memoization table storing results for all possible (i,j,k) combinations

⚠ Quadratic Space

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

Recursive Brute Force with Memoization — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler