Maximize Score After Pair Deletions

Maximize Score After Pair Deletions - Problem

Array Greedy Medium

You are given an array of integers nums. You must repeatedly perform one of the following operations while the array has more than two elements:

Remove the first two elements.
Remove the last two elements.
Remove the first and last element.

For each operation, add the sum of the removed elements to your total score.

Return the maximum possible score you can achieve.

Input & Output

Example 1 — Basic Case

$ Input: nums = [6,2,3,4]

› Output: 15

💡 Note: Multiple ways to achieve score 15: Remove [6,2] (score 8), then [3,4] (score 7). Total: 8+7=15. Or remove [3,4] first (score 7), then [6,2] (score 8). Both give maximum score 15.

Example 2 — Small Array

$ Input: nums = [2,7,9,4,5]

› Output: 27

💡 Note: Optimal sequence: Remove [2,5] (first+last, score 7), then [7,4] (first+last, score 11), leaving [9] (score 9). Total: 7+11+9=27.

Example 3 — Minimum Size

$ Input: nums = [1,2]

› Output: 3

💡 Note: Array has exactly 2 elements, so we sum them all: 1+2=3. No operations are performed since we need more than 2 elements to operate.

Constraints

2 ≤ nums.length ≤ 10³
-10⁶ ≤ nums[i] ≤ 10⁶

Visualization

Tap to expand

Asked in

G Google 15 f Facebook 12 a Amazon 8

This problem requires finding the maximum score by strategically removing pairs of elements. The key insight is that at each step, we have exactly 3 choices and need to pick the one leading to maximum total score. The optimal approach uses dynamic programming to solve overlapping subproblems efficiently. Time: O(n²), Space: O(n²).

Common Approaches

✓ Bottom-Up Dynamic Programming

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

Create a 2D DP table where dp[i][j] represents the maximum score for subarray from index i to j. Fill the table bottom-up, starting from smaller subarrays and building up to the full array.

Brute Force Recursion

⏱️ Time: O(3ⁿ) Space: O(n)

For each state of the array, try all three possible operations and recursively find the maximum score from the remaining array. This explores every possible game sequence.

Memoization (Top-Down DP)

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

Same recursive approach as brute force, but store results of each subproblem (defined by left and right boundaries) in a cache to avoid recalculating the same state multiple times.

Bottom-Up Dynamic Programming — Algorithm Steps

Step 1: Create dp[n][n] table
Step 2: Fill base cases (length ≤ 2)
Step 3: Fill table for increasing lengths
Step 4: For each range, try 3 operations and take maximum

Visualization

Tap to expand

Step-by-Step Walkthrough

Base Cases

Fill length 1 and 2 subarrays

Build Up

Fill larger subarrays using smaller ones

Final Answer

dp[0][n-1] contains the maximum score

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* nums, int n) {
    if (n <= 2) {
        int sum = 0;
        for (int i = 0; i < n; i++) {
            sum += nums[i];
        }
        return sum;
    }
    
    // dp[i][j] = maximum score for subarray nums[i:j+1]
    int dp[100][100];
    memset(dp, 0, sizeof(dp));
    
    // Base cases: arrays of length 1 and 2
    for (int i = 0; i < n; i++) {
        dp[i][i] = nums[i];
        if (i + 1 < n) {
            dp[i][i + 1] = nums[i] + nums[i + 1];
        }
    }
    
    // Fill for lengths 3 and above
    for (int length = 3; length <= n; length++) {
        for (int i = 0; i <= n - length; i++) {
            int j = i + length - 1;
            
            // Option 1: Remove first two elements
            if (i + 2 <= j) {
                dp[i][j] = max(dp[i][j], nums[i] + nums[i + 1] + dp[i + 2][j]);
            }
            
            // Option 2: Remove last two elements
            if (i <= j - 2) {
                dp[i][j] = max(dp[i][j], nums[j - 1] + nums[j] + dp[i][j - 2]);
            }
            
            // Option 3: Remove first and last elements
            if (i + 1 <= j - 1) {
                dp[i][j] = max(dp[i][j], nums[i] + nums[j] + dp[i + 1][j - 1]);
            }
        }
    }
    
    return dp[0][n - 1];
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    int nums[100];
    int n = 0;
    
    char* token = strtok(line, "[,]");
    while (token != NULL) {
        if (token[0] >= '0' && token[0] <= '9' || token[0] == '-') {
            nums[n++] = atoi(token);
        }
        token = strtok(NULL, "[,]");
    }
    
    printf("%d\n", solution(nums, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Triple nested loops: outer for length, middle for start position, inner for 3 operations

⚠ Quadratic Growth

Space Complexity

O(n²)

2D DP table to store maximum score for each subarray range

⚠ Quadratic Space

18.5K Views

Medium Frequency

~25 min Avg. Time

750 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

Bottom-Up Dynamic Programming — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler