Maximize Subarray GCD Score - Practice Coding Problems

Maximize Subarray GCD Score - Problem

You're given an array of positive integers nums and an integer k representing the maximum number of operations you can perform. Your goal is to maximize the score of any contiguous subarray after applying strategic modifications.

Operations Available:

You can perform at most k operations
Each operation doubles the value of any element in the array
Each element can be doubled at most once

Subarray Score Calculation:

The score of a contiguous subarray equals: Length × GCD(all elements in subarray)

Where GCD is the Greatest Common Divisor - the largest integer that evenly divides all elements in the subarray.

Your Task: Return the maximum possible score achievable by selecting any contiguous subarray from the strategically modified array.

Example: For nums = [12, 18, 6], k = 1, if we double the element 6 to get [12, 18, 12], the subarray [12, 18, 12] has GCD = 6 and length = 3, giving score = 18.

Input & Output

example_1.py — Basic case

$ Input: [12, 18, 6] k = 1

› Output: 24

💡 Note: Double the element 12 to get [24, 18, 6]. The subarray [24] has GCD=24 and length=1, giving score=24. This is better than keeping the original array where [12, 18, 6] has GCD=6 and score=18.

example_2.py — Multiple operations

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

› Output: 24

💡 Note: Double two elements to get [8, 8, 4]. The subarray [8, 8] has GCD=8 and length=2, giving score=16. Or double to get [4, 8, 8] where [8, 8] gives score=16. Actually, [8, 4] has GCD=4, so [8, 8, 4] has GCD=4 and score=12. The best is doubling to get [8, 8, 4] and taking [8, 8] for score=16.

example_3.py — No operations needed

$ Input: [10, 20, 30] k = 0

› Output: 30

💡 Note: Cannot perform any operations. The subarray [30] has GCD=30 and length=1, giving the maximum score=30. The full array [10, 20, 30] has GCD=10 and length=3, giving score=30 as well.

Constraints

1 ≤ nums.length ≤ 100
1 ≤ nums[i] ≤ 10⁶
0 ≤ k ≤ nums.length
Each element can be doubled at most once
All array elements are positive integers

Visualization

Tap to expand

Understanding the Visualization

Identify Harmony Levels

List all possible GCD values that could be achieved

Group Musicians

For each harmony level, find which musicians can contribute

Optimize Volume

Decide how to best use limited volume boosts (k operations)

Find Best Section

Locate the longest consecutive group achieving target harmony

Key Takeaway

🎯 Key Insight: By systematically exploring all possible harmony levels (GCD values) instead of all possible volume boost combinations, we can efficiently find the optimal strategy that maximizes the total score.

Asked in

G Google 45 ⊞ Microsoft 38 f Meta 22 a Amazon 15

The optimal solution uses GCD enumeration - instead of trying all possible ways to distribute doublings, we enumerate all possible GCD values and find the optimal strategy for each. Key insight: there are only O(d·n) meaningful GCD candidates where d is the number of divisors, making this approach much more efficient than brute force while still finding the optimal answer.

Common Approaches

Approach	Time	Space	Notes
✓ GCD Enumeration (Optimal)	O(n² × d × log(max_val))	O(n + d)	Enumerate possible GCD values and find optimal doubling strategy for each
Brute Force (Try All Combinations)	O(C(n,k) × n² × n × log(max_val))	O(n)	Try every possible way to distribute k doublings and check all subarrays

GCD Enumeration (Optimal) — Algorithm Steps

Collect all possible GCD candidates from original array and doubled values
For each potential GCD value, find all elements that could contribute to achieving this GCD
Use dynamic programming or greedy approach to find the optimal doubling strategy for each GCD
For each GCD and doubling strategy, find the longest contiguous subarray with that GCD
Return the maximum score across all possibilities

Visualization

Tap to expand

Step-by-Step Walkthrough

Collect GCD candidates

Find all possible GCD values from divisors

For each GCD

Determine which elements can contribute

Optimize doublings

Find best way to use k operations for this GCD

Find best subarray

Locate longest subarray achieving this GCD

Code -

solution.c — C

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

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

int cmpDesc(const void *a, const void *b) {
    return (*(int*)b - *(int*)a);
}

int getDivisors(int n, int* divisors) {
    int count = 0;
    for (int i = 1; i * i <= n; i++) {
        if (n % i == 0) {
            divisors[count++] = i;
            if (i != n / i) {
                divisors[count++] = n / i;
            }
        }
    }
    qsort(divisors, count, sizeof(int), cmpDesc);
    return count;
}

int min(int a, int b) {
    return a < b ? a : b;
}

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

int maxSubarrayGCDScore(int* nums, int n, int k) {
    int maxScore = 0;
    int candidates[10000];
    int candidateCount = 0;
    
    // Collect all divisor candidates
    for (int i = 0; i < n; i++) {
        int divs[1000];
        int divCount = getDivisors(nums[i], divs);
        for (int j = 0; j < divCount; j++) {
            int found = 0;
            for (int c = 0; c < candidateCount; c++) {
                if (candidates[c] == divs[j]) {
                    found = 1;
                    break;
                }
            }
            if (!found) {
                candidates[candidateCount++] = divs[j];
            }
        }
        
        divCount = getDivisors(nums[i] * 2, divs);
        for (int j = 0; j < divCount; j++) {
            int found = 0;
            for (int c = 0; c < candidateCount; c++) {
                if (candidates[c] == divs[j]) {
                    found = 1;
                    break;
                }
            }
            if (!found) {
                candidates[candidateCount++] = divs[j];
            }
        }
    }
    
    for (int c = 0; c < candidateCount; c++) {
        int targetGcd = candidates[c];
        
        // Find eligible elements
        int eligible[100][2];
        int eligibleCount = 0;
        
        for (int i = 0; i < n; i++) {
            if (nums[i] % targetGcd == 0) {
                eligible[eligibleCount][0] = i;
                eligible[eligibleCount][1] = nums[i] / targetGcd;
                eligibleCount++;
            } else if ((nums[i] * 2) % targetGcd == 0) {
                eligible[eligibleCount][0] = i;
                eligible[eligibleCount][1] = (nums[i] * 2) / targetGcd;
                eligibleCount++;
            }
        }
        
        if (eligibleCount == 0) continue;
        
        int maxMask = min(1 << eligibleCount, 1 << min(20, eligibleCount));
        for (int mask = 0; mask < maxMask; mask++) {
            int doublesUsed = 0;
            int modified[100];
            memcpy(modified, nums, n * sizeof(int));
            int valid = 1;
            
            for (int j = 0; j < eligibleCount; j++) {
                int idx = eligible[j][0];
                if (mask & (1 << j)) {
                    if (nums[idx] % targetGcd != 0) {
                        modified[idx] *= 2;
                        doublesUsed++;
                    }
                } else {
                    if (nums[idx] % targetGcd != 0) {
                        valid = 0;
                        break;
                    }
                }
            }
            
            if (!valid || doublesUsed > k) continue;
            
            for (int i = 0; i < n; i++) {
                int currentGcd = 0;
                for (int j = i; j < n; j++) {
                    if (modified[j] % targetGcd != 0) break;
                    currentGcd = (currentGcd == 0) ? modified[j] : gcd(currentGcd, modified[j]);
                    if (currentGcd >= targetGcd) {
                        int score = (j - i + 1) * currentGcd;
                        maxScore = max(maxScore, score);
                    }
                }
            }
        }
    }
    
    return maxScore;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n² × d × log(max_val))

n² for checking subarrays, d for number of divisors to enumerate, log factor for GCD calculations

⚠ Quadratic Growth

Space Complexity

O(n + d)

Space for storing candidates and temporary arrays

⚡ Linearithmic Space

27.5K Views

Medium-High Frequency

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

GCD Enumeration (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler