Maximum Number of Operations With the Same Score II

Maximum Number of Operations With the Same Score II - Problem

You're given an array of integers nums, and you need to perform operations to remove pairs of elements. Each operation removes exactly two elements and gives you a score equal to the sum of those elements.

You have three choices for each operation:

🔸 Remove the first two elements: nums[0] + nums[1]
🔸 Remove the last two elements: nums[n-2] + nums[n-1]
🔸 Remove the first and last elements: nums[0] + nums[n-1]

Challenge: Find the maximum number of operations you can perform such that all operations have the same score.

Example: With [3,2,1,4,5], if you choose score 8, you could remove (3,5) → score 8, then (2,6) → but 6 isn't available! You need to plan ahead to maximize operations with consistent scoring.

Input & Output

example_1.py — Basic Case

$ Input: nums = [3,2,1,4,5]

› Output: 2

💡 Note: We can choose target score 8. First, remove first and last elements (3,5) → score 8. Then remove first and last from remaining [2,1,4] → (2,4) → score 6. Since 6 ≠ 8, we can't continue. Actually, the optimal is target score 6: remove (2,4) → score 6, then (3,1) → score 4. Wait, that doesn't work either. Let's try target 7: remove first two (3,2) → score 5. That doesn't match target 7. The correct answer is trying target 7 from last two (4,5): remove (4,5) → score 9, not 7. The actual optimal path gives us 2 operations maximum.

example_2.py — All Same Pairs

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

› Output: 1

💡 Note: Possible target scores: 3+2=5, 6+1=7, 4+1=5, 3+4=7. If we choose target 5: we can remove (3,2) for score 5, leaving [6,1,4]. Now we need pairs that sum to 5, but 6+1=7, 6+4=10, 1+4=5. So we can remove (1,4) for score 5, leaving [6]. Since we need at least 2 elements, we stop. That's 2 operations. But let's verify this is actually achievable...

example_3.py — Edge Case

$ Input: nums = [1,1]

› Output: 1

💡 Note: With only 2 elements, we can perform exactly 1 operation. The only option is to remove both elements (1,1) with score 2. Result: 1 operation.

Constraints

2 ≤ nums.length ≤ 2000
1 ≤ nums[i] ≤ 1000
The array will have at least 2 elements for meaningful operations

Visualization

Tap to expand

Understanding the Visualization

Choose Target Score

Try each of the 3 possible first moves to set target score

Recursive Exploration

For each remaining configuration, try all valid moves matching target

Memoize Results

Cache results to avoid recalculating same subproblems

Return Maximum

Take the best result across all 3 target scores

Asked in

G Google 28 a Amazon 22 f Meta 18 ⊞ Microsoft 15

The optimal approach uses dynamic programming with memoization. Since there are only 3 possible target scores (from the first move), we can try each target and use memoized recursion to find the maximum operations. The key insight is that subproblems defined by (left, right, target) will be repeated, so caching results gives us O(n²) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Recursive Backtracking	O(3^n)	O(n)	Try all possible operation sequences recursively without memoization
Dynamic Programming with Memoization (Optimal)	O(n²)	O(n²)	Use memoization to cache results of subproblems and avoid redundant calculations

Recursive Backtracking — Algorithm Steps

Try the first move (3 options) to determine target score
For each remaining state, try all valid moves that match target score
Recursively explore each valid path
Return maximum operations found across all paths
Repeat for all 3 possible target scores

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Start with full array and 3 possible target scores

Branch Exploration

For each target, try all 3 operations recursively

Backtrack

Return maximum operations found across all branches

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 backtrack(int* nums, int left, int right, int target, int ops) {
    if (right - left < 1) {
        return ops;
    }
    
    int maxOps = ops;
    
    // Try first two elements
    if (left + 1 <= right && nums[left] + nums[left + 1] == target) {
        maxOps = max(maxOps, backtrack(nums, left + 2, right, target, ops + 1));
    }
    
    // Try last two elements
    if (left <= right - 1 && nums[right - 1] + nums[right] == target) {
        maxOps = max(maxOps, backtrack(nums, left, right - 2, target, ops + 1));
    }
    
    // Try first and last elements
    if (left < right && nums[left] + nums[right] == target) {
        maxOps = max(maxOps, backtrack(nums, left + 1, right - 1, target, ops + 1));
    }
    
    return maxOps;
}

int maxOperations(int* nums, int numsSize) {
    if (numsSize < 2) return 0;
    
    int target1 = nums[0] + nums[1];
    int target2 = nums[numsSize-2] + nums[numsSize-1];
    int target3 = nums[0] + nums[numsSize-1];
    
    int result1 = backtrack(nums, 0, numsSize-1, target1, 0);
    int result2 = backtrack(nums, 0, numsSize-1, target2, 0);
    int result3 = backtrack(nums, 0, numsSize-1, target3, 0);
    
    return max(max(result1, result2), result3);
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    int nums[500];
    int count = 0;
    char* token = strtok(line, " \n");
    while (token != NULL) {
        nums[count++] = atoi(token);
        token = strtok(NULL, " \n");
    }
    
    printf("%d\n", maxOperations(nums, count));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(3^n)

At each step we have up to 3 choices, leading to exponential branching

✓ Linear Growth

Space Complexity

O(n)

Recursion depth is at most n/2 operations, each storing array bounds

⚡ Linearithmic Space

24.6K Views

Medium Frequency

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

Recursive Backtracking — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler