Maximize Subarray GCD Score

Maximize Subarray GCD Score - Problem

You are given an array of positive integers nums and an integer k. You may perform at most k operations. In each operation, you can choose one element in the array and double its value. Each element can be doubled at most once.

The score of a contiguous subarray is defined as the product of its length and the greatest common divisor (GCD) of all its elements.

Your task is to return the maximum score that can be achieved by selecting a contiguous subarray from the modified array.

Note: The greatest common divisor (GCD) of an array is the largest integer that evenly divides all the array elements.

Input & Output

Example 1 — Basic Case

$ Input: nums = [4,6,8], k = 1

› Output: 16

💡 Note: Double the element 8 to get [4,6,16]. The subarray [16] has GCD=16 and length=1, giving score 1×16=16, which is the maximum possible.

Example 2 — Multiple Operations

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

› Output: 12

💡 Note: Double elements at indices 0 and 1: [2,4,6] → [4,8,6]. The subarray [4,8] has GCD=4 and length=2, giving score 2×4=8. The subarray [4,8,6] has GCD=2 and length=3, giving score 3×2=6. Better: double 2→4 and 6→12: [4,4,12] subarray [4,4] has GCD=4, score=8. Actually [4] alone has score=4. Check [4,4,12]: GCD=4, but wait GCD([4,4,12])=4, score=12.

Example 3 — No Operations Needed

$ Input: nums = [12,12,12], k = 0

› Output: 36

💡 Note: No doubling allowed. The entire array [12,12,12] has GCD=12 and length=3, giving score 3×12=36.

Constraints

1 ≤ nums.length ≤ 10
1 ≤ nums[i] ≤ 100
0 ≤ k ≤ nums.length

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 18 M Microsoft 15

The key insight is to enumerate all subarrays and find optimal doubling strategy for each. For small arrays, we can afford to check all 2^n doubling combinations per subarray. Best approach is subarray enumeration with greedy optimization. Time: O(n⁴), Space: O(n)

Common Approaches

✓ Try All Combinations

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

Generate all possible combinations of doubling operations (2^n possibilities), then for each modified array, check all possible subarrays to find maximum score.

Enumerate Subarrays with Greedy Doubling

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

Iterate through all possible subarrays, and for each subarray, determine the optimal set of elements to double that maximizes the GCD of that subarray.

Try All Combinations — Algorithm Steps

Generate all 2^n ways to double elements
For each configuration, calculate GCD of all subarrays
Track maximum score across all possibilities

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Combinations

Try all ways to double k elements

Check All Subarrays

For each combination, test all subarrays

Calculate Scores

Find length × GCD for each subarray

Code -

solution.c — C

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

int gcd(int a, int b) {
    return b == 0 ? a : gcd(b, a % b);
}

int popcount(int x) {
    int count = 0;
    while (x) {
        count += x & 1;
        x >>= 1;
    }
    return count;
}

int solution(int* nums, int n, int k) {
    int maxScore = 0;
    
    // Try all combinations of doubling at most k elements
    for (int mask = 0; mask < (1 << n); mask++) {
        if (popcount(mask) > k) continue;
        
        // Create modified array
        int modified[n];
        for (int i = 0; i < n; i++) {
            modified[i] = nums[i];
            if (mask & (1 << i)) {
                modified[i] *= 2;
            }
        }
        
        // Check all subarrays
        for (int i = 0; i < n; i++) {
            for (int j = i; j < n; j++) {
                int gcdVal = modified[i];
                for (int x = i + 1; x <= j; x++) {
                    gcdVal = gcd(gcdVal, modified[x]);
                }
                int score = (j - i + 1) * gcdVal;
                if (score > maxScore) {
                    maxScore = score;
                }
            }
        }
    }
    
    return maxScore;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array manually
    int nums[100];
    int n = 0;
    char* token = strtok(line, "[],\n");
    while (token != NULL) {
        nums[n++] = atoi(token);
        token = strtok(NULL, "[],\n");
    }
    
    int k;
    scanf("%d", &k);
    
    int result = solution(nums, n, k);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n × n³)

2^n combinations × n² subarrays × n GCD calculations

⚠ Quadratic Growth

Space Complexity

O(n)

Space for modified array and GCD calculations

⚡ Linearithmic Space

12.5K Views

Medium Frequency

~35 min Avg. Time

420 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

Try All Combinations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler