Remove Boxes

Remove Boxes - Problem

You are given several boxes with different colors represented by different positive numbers.

You may experience several rounds to remove boxes until there is no box left. Each time you can choose some continuous boxes with the same color (i.e., composed of k boxes, k >= 1), remove them and get k * k points.

Return the maximum points you can get.

Input & Output

Example 1 — Basic Case

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

› Output: 23

💡 Note: Remove three 2s (3×3=9 points), then remove two 3s (2×2=4 points), then remove remaining boxes one by one. Total: 9+4+1+1+1+1+1+1+1+1+1+1 = 23 points.

Example 2 — All Same Color

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

› Output: 9

💡 Note: Remove all three boxes at once: 3×3 = 9 points.

Example 3 — Single Box

$ Input: boxes = [1]

› Output: 1

💡 Note: Only one box to remove: 1×1 = 1 point.

Constraints

1 ≤ boxes.length ≤ 100
1 ≤ boxes[i] ≤ 100

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 8 M Microsoft 5

The key insight is that sometimes it's optimal to skip over boxes of different colors to collect more boxes of the same color later, since k boxes give k² points. The best approach uses 3D Dynamic Programming with state dp[i][j][k] representing maximum points for interval [i,j] with k extra boxes of color boxes[j]. Time: O(n³), Space: O(n³)

Common Approaches

✓ 3D Dynamic Programming

⏱️ Time: O(n³) Space: O(n³)

Use 3D DP where dp[i][j][k] represents maximum points for boxes[i:j+1] with k extra boxes of color boxes[j] that can be attached. The key insight is to either remove boxes[j] with k extra boxes or find intermediate points to split optimally.

Memoized Recursion

⏱️ Time: O(2^n) Space: O(2^n)

Use memoization to store results of subproblems based on the current state of boxes. This reduces time complexity by avoiding repeated calculations of the same configurations.

Recursive Brute Force

⏱️ Time: O(n!) Space: O(n)

For each contiguous segment of same-colored boxes, recursively try removing it and solve the remaining subproblems. This explores all possible removal orders but has exponential time complexity due to overlapping subproblems.

3D Dynamic Programming — Algorithm Steps

Initialize 3D DP table
For each interval [i,j] and extra count k
Try removing j with k extras or split at intermediate points
Return dp[0][n-1][0] as final answer

Visualization

Tap to expand

Step-by-Step Walkthrough

3D State

dp[i][j][k] = max points for interval with k extras

Two Options

Remove end box or find matching intermediate box

Optimal

Choose option that maximizes points

Code -

solution.c — C

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

int max(int a, int b) {
    return a > b ? a : b;
}

int solution(int* boxes, int n) {
    if (n == 0) return 0;
    
    // Allocate 3D DP array
    int*** dp = (int***)malloc(n * sizeof(int**));
    for (int i = 0; i < n; i++) {
        dp[i] = (int**)malloc(n * sizeof(int*));
        for (int j = 0; j < n; j++) {
            dp[i][j] = (int*)calloc(n, sizeof(int));
        }
    }
    
    // Base case: single box intervals
    for (int i = 0; i < n; i++) {
        for (int k = 0; k < n; k++) {
            dp[i][i][k] = (k + 1) * (k + 1);
        }
    }
    
    // Fill DP table for increasing interval lengths
    for (int length = 2; length <= n; length++) {
        for (int i = 0; i <= n - length; i++) {
            int j = i + length - 1;
            for (int k = 0; k < n; k++) {
                // Option 1: Remove boxes[j] with k extra boxes
                dp[i][j][k] = dp[i][j-1][0] + (k + 1) * (k + 1);
                
                // Option 2: Find intermediate point m where boxes[m] == boxes[j]
                for (int m = i; m < j; m++) {
                    if (boxes[m] == boxes[j]) {
                        dp[i][j][k] = max(dp[i][j][k], 
                                        dp[i][m][k+1] + dp[m+1][j-1][0]);
                    }
                }
            }
        }
    }
    
    int result = dp[0][n-1][0];
    
    // Free memory
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            free(dp[i][j]);
        }
        free(dp[i]);
    }
    free(dp);
    
    return result;
}

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[1000];
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    int boxes[100];
    int len = 0;
    char* token = strtok(line + 1, ",]");
    while (token != NULL) {
        boxes[len++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    printf("%d\n", solution(boxes, len));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Three nested loops for i, j, and k with n iterations each

⚠ Quadratic Growth

Space Complexity

O(n³)

3D DP table of size n×n×n

⚠ Quadratic Space

18.5K Views

Medium Frequency

~45 min Avg. Time

892 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 — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler