Codestin Search App

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
✓ 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)	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) — Algorithm Steps

Generate all possible combinations of doubling k elements (respecting the constraint that each element can be doubled at most once)
For each combination, create the modified array
For each modified array, check all possible contiguous subarrays
Calculate GCD and score for each subarray
Track the maximum score found

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate combinations

List all ways to choose k elements to double

Apply doublings

Create modified array for each combination

Check subarrays

Calculate score for every contiguous subarray

Track maximum

Keep the highest score found

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 arrayGcd(int* arr, int len) {
    int result = arr[0];
    for (int i = 1; i < len; i++) {
        result = gcd(result, arr[i]);
    }
    return result;
}

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

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

void generateCombinations(int n, int k, int start, int* current, int currentLen, int combinations[][100], int* combCount, int* combLens) {
    if (currentLen == k) {
        for (int i = 0; i < k; i++) {
            combinations[*combCount][i] = current[i];
        }
        combLens[*combCount] = k;
        (*combCount)++;
        return;
    }
    for (int i = start; i < n; i++) {
        current[currentLen] = i;
        generateCombinations(n, k, i + 1, current, currentLen + 1, combinations, combCount, combLens);
    }
}

int maxSubarrayGCDScore(int* nums, int n, int k) {
    int maxScore = 0;
    int combinations[1000][100];
    int combLens[1000];
    int combCount = 0;
    int current[100];
    
    generateCombinations(n, min(k, n), 0, current, 0, combinations, &combCount, combLens);
    
    for (int c = 0; c < combCount; c++) {
        int modified[100];
        memcpy(modified, nums, n * sizeof(int));
        
        for (int i = 0; i < combLens[c]; i++) {
            int idx = combinations[c][i];
            modified[idx] *= 2;
        }
        
        for (int i = 0; i < n; i++) {
            for (int j = i; j < n; j++) {
                int subarrayLen = j - i + 1;
                int subarrayGcd = arrayGcd(&modified[i], subarrayLen);
                int score = subarrayLen * subarrayGcd;
                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(C(n,k) × n² × n × log(max_val))

C(n,k) ways to choose elements to double, n² subarrays, n elements per GCD calculation, log factor for GCD

⚠ Quadratic Growth

Space Complexity

O(n)

Space for storing the modified array and temporary calculations

⚡ 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

Brute Force (Try All Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler