Maximize Score After N Operations - Practice Coding Problems

Maximize Score After N Operations - Problem

Array Math Dynamic Programming Backtracking Bit Manipulation Number Theory Bitmask Hard

Maximize Score After N Operations

You're playing a strategic number game! Given an array nums containing 2*n positive integers, you need to perform exactly n operations to maximize your total score.

In each operation i (starting from 1), you must:
• Choose any two elements x and y from the remaining numbers
• Calculate your score: i × gcd(x, y)
• Remove both elements from the array

Your goal is to strategically choose pairs to maximize the total score across all operations. The catch? Later operations are worth more points (multiplied by the operation number), but you have fewer choices as elements get removed!

Example: With [1, 2, 3, 4, 5, 6] and n=3:
• Operation 1: Choose (1,5) → Score = 1 × gcd(1,5) = 1 × 1 = 1
• Operation 2: Choose (2,4) → Score = 2 × gcd(2,4) = 2 × 2 = 4
• Operation 3: Choose (3,6) → Score = 3 × gcd(3,6) = 3 × 3 = 9
• Total Score: 1 + 4 + 9 = 14

Input & Output

example_1.py — Python

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

› Output: 14

💡 Note: One optimal strategy: Operation 1: choose (1,5) → score = 1×gcd(1,5) = 1×1 = 1. Operation 2: choose (2,4) → score = 2×gcd(2,4) = 2×2 = 4. Operation 3: choose (3,6) → score = 3×gcd(3,6) = 3×3 = 9. Total = 1+4+9 = 14

example_2.py — Python

$ Input: [3, 4, 6, 8]

› Output: 11

💡 Note: Operation 1: choose (3,6) → score = 1×gcd(3,6) = 1×3 = 3. Operation 2: choose (4,8) → score = 2×gcd(4,8) = 2×4 = 8. Total = 3+8 = 11

example_3.py — Python

$ Input: [1, 1]

› Output: 1

💡 Note: Only one operation possible: choose (1,1) → score = 1×gcd(1,1) = 1×1 = 1

Visualization

Tap to expand

Understanding the Visualization

Setup

You have 2n cards with numbers, need to make n pairs

Strategy

Later rounds have higher multipliers, so save high-GCD pairs for later

Execution

Use DP with bitmasks to try all strategies efficiently

Optimization

Memoize results to avoid recalculating the same game states

Key Takeaway

🎯 Key Insight: Use dynamic programming with bitmasks to efficiently explore all pairing strategies while memoizing results to avoid redundant calculations.

Time & Space Complexity

Time Complexity

⏱️

O(4^n)

There are 2^(2n) possible states, and for each state we try O(n^2) pairs

✓ Linear Growth

Space Complexity

O(2^(2n))

We need to store the result for each possible bitmask state

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 7 (so 2 ≤ nums.length ≤ 14)
1 ≤ nums[i] ≤ 10⁶
nums.length == 2 * n (always even number of elements)

Asked in

G Google 45 ⊞ Microsoft 32 a Amazon 28 f Meta 15

The optimal approach uses dynamic programming with bitmasks to efficiently explore all possible pairing strategies. By memoizing results for each state (represented by which elements are used), we avoid redundant calculations and achieve O(4^n) time complexity, which is acceptable given the constraint n ≤ 7.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming with Bitmask (Optimal)	O(4^n)	O(2^(2n))	Use bitmask DP to avoid recomputing the same subproblems

Dynamic Programming with Bitmask (Optimal) — Algorithm Steps

Use a bitmask to represent which elements are used
For each state, try all possible pairs from unused elements
Memoize results to avoid recomputation
The answer is the result for the empty mask (no elements used yet)

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Mask = 0000 (no elements used)

First Operation

Try pairs, update mask to mark used elements

Memoization

Store result for each mask to avoid recomputation

Optimal Path

Build solution using stored optimal subproblems

Code -

solution.c — C

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

#define MAXN 14
#define MAXMASK (1 << MAXN)

int memo[MAXMASK];
int nums[MAXN];
int n, size;

int gcd(int a, int b) {
    while (b != 0) {
        int temp = b;
        b = a % b;
        a = temp;
    }
    return a;
}

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

int dp(int mask, int operation) {
    if (operation > n) {
        return 0;
    }
    
    if (memo[mask] != -1) {
        return memo[mask];
    }
    
    int maxScore = 0;
    
    // Find all unused elements
    int unused[MAXN];
    int count = 0;
    for (int i = 0; i < size; i++) {
        if (!(mask & (1 << i))) {
            unused[count++] = i;
        }
    }
    
    // Try all pairs of unused elements
    for (int i = 0; i < count; i++) {
        for (int j = i + 1; j < count; j++) {
            int idx1 = unused[i], idx2 = unused[j];
            
            // Mark these elements as used
            int newMask = mask | (1 << idx1) | (1 << idx2);
            
            // Calculate score and recurse
            int pairScore = operation * gcd(nums[idx1], nums[idx2]);
            int totalScore = pairScore + dp(newMask, operation + 1);
            
            maxScore = max(maxScore, totalScore);
        }
    }
    
    memo[mask] = maxScore;
    return maxScore;
}

int maxScore() {
    memset(memo, -1, sizeof(memo));
    return dp(0, 1);
}

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

Time & Space Complexity

Time Complexity

⏱️

O(4^n)

There are 2^(2n) possible states, and for each state we try O(n^2) pairs

✓ Linear Growth

Space Complexity

O(2^(2n))

We need to store the result for each possible bitmask state

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 7 (so 2 ≤ nums.length ≤ 14)
1 ≤ nums[i] ≤ 10⁶
nums.length == 2 * n (always even number of elements)

52.8K Views

Medium Frequency

~25 min Avg. Time

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Dynamic Programming with Bitmask (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler