Maximize Score After Pair Deletions - Practice Coding Problems

Maximize Score After Pair Deletions - Problem

Array Greedy Medium

Maximize Score After Pair Deletions is an engaging array manipulation problem that tests your understanding of dynamic programming and optimal substructure.

You're given an array of integers nums and must repeatedly perform operations to remove pairs of elements while maximizing your total score. At each step, you can choose one of three operations:

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

For each operation, you add the sum of the removed elements to your score. Continue until the array has 2 or fewer elements remaining.

Goal: Return the maximum possible score you can achieve through optimal operation choices.

Example: For nums = [3, 7, 2, 3], you could remove first and last (3+3=6), then remove remaining two (7+2=9), for a total score of 15.

Input & Output

example_1.py — Basic case

$ Input: [3, 7, 2, 3]

› Output: 15

💡 Note: Remove first and last elements (3 + 3 = 6), then remove remaining elements (7 + 2 = 9). Total score: 6 + 9 = 15.

example_2.py — Small array

$ Input: [1, 5]

› Output: 6

💡 Note: Only two elements remain, so we can remove them in any valid way. Score: 1 + 5 = 6.

example_3.py — Larger array

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

› Output: 21

💡 Note: Optimal strategy: Remove first+last (4+5=9), then first+last (1+6=7), then remaining (3+2=5). Total: 9+7+5=21.

Constraints

2 ≤ nums.length ≤ 100
1 ≤ nums[i] ≤ 1000
All integers in nums are positive

Visualization

Tap to expand

Understanding the Visualization

Initial State

Start with array of values, need to make optimal removal decisions

Three Choices

At each step, can remove first two, last two, or first and last elements

Memoization

Store results of subproblems to avoid recalculation

Optimal Solution

Build up optimal solution from cached subproblem results

Key Takeaway

🎯 Key Insight: The problem exhibits optimal substructure, making dynamic programming with memoization the perfect solution approach.

Asked in

G Google 42 a Amazon 38 ⊞ Microsoft 29 f Meta 25

This problem is optimally solved using dynamic programming with memoization. The key insight is recognizing the optimal substructure - the maximum score for any range depends on the maximum scores of smaller ranges. By caching results in a 2D table, we achieve O(n²) time complexity instead of the exponential time of the brute force approach.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Recursive Exploration)	O(3^n)	O(n)	Try all possible sequences of operations recursively
Dynamic Programming (Optimal)	O(n²)	O(n²)	Use memoization to avoid recalculating the same subproblems

Brute Force (Recursive Exploration) — Algorithm Steps

For current array range, try all three operations
Recursively calculate score for remaining elements
Return maximum of all three choices
Base case: return 0 when fewer than 2 elements remain

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial Array

Start with the complete array and three possible operations

Branch Creation

For each operation, create a new branch exploring that choice

Recursive Exploration

Continue branching until base case is reached

Score Calculation

Calculate total score by summing up all removal operations

Code -

solution.c — C

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

int solve(int* nums, int left, int right) {
    // Base case: less than 2 elements
    if (right - left + 1 < 2) {
        return 0;
    }
    
    int maxScore = 0;
    
    // Option 1: Remove first two elements
    if (right - left + 1 >= 2) {
        int score1 = nums[left] + nums[left + 1] + solve(nums, left + 2, right);
        if (score1 > maxScore) maxScore = score1;
    }
    
    // Option 2: Remove last two elements
    if (right - left + 1 >= 2) {
        int score2 = nums[right - 1] + nums[right] + solve(nums, left, right - 2);
        if (score2 > maxScore) maxScore = score2;
    }
    
    // Option 3: Remove first and last elements
    if (right - left + 1 >= 2) {
        int score3 = nums[left] + nums[right] + solve(nums, left + 1, right - 1);
        if (score3 > maxScore) maxScore = score3;
    }
    
    return maxScore;
}

int maxScoreAfterDeletions(int* nums, int size) {
    return solve(nums, 0, size - 1);
}

int main() {
    char input[1000];
    fgets(input, sizeof(input), stdin);
    
    // Parse input
    int nums[100];
    int size = 0;
    char* token = strtok(input, "[],");
    while (token != NULL) {
        nums[size++] = atoi(token);
        token = strtok(NULL, "[],");
    }
    
    printf("%d\n", maxScoreAfterDeletions(nums, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(3^n)

At each step we have 3 choices, and we might need to make up to n/2 decisions, leading to exponential growth

✓ Linear Growth

Space Complexity

O(n)

Recursion stack depth is at most n/2 levels deep

⚡ Linearithmic Space

58.2K Views

Medium Frequency

~18 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

Brute Force (Recursive Exploration) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler