Maximum GCD-Sum of a Subarray

Maximum GCD-Sum of a Subarray - Problem

You are given an array of integers nums and an integer k.

The gcd-sum of an array a is calculated as follows:

Let s be the sum of all the elements of a.
Let g be the greatest common divisor of all the elements of a.
The gcd-sum of a is equal to s * g.

Return the maximum gcd-sum of a subarray of nums with at least k elements.

Input & Output

Example 1 — Basic Case

$ Input: nums = [6,10,3], k = 2

› Output: 32

💡 Note: Subarray [6,10] has sum=16, gcd=gcd(6,10)=2, so gcd-sum = 16×2 = 32. Subarray [10,3] has sum=13, gcd=1, gcd-sum=13. Subarray [6,10,3] has sum=19, gcd=1, gcd-sum=19. Maximum is 32.

Example 2 — All Elements

$ Input: nums = [4,4,4,4], k = 3

› Output: 48

💡 Note: Any subarray of length 3 has sum=12 and gcd=4, giving gcd-sum = 12×4 = 48

Example 3 — Minimum Length

$ Input: nums = [5,10], k = 2

› Output: 75

💡 Note: Only one subarray [5,10]: sum=15, gcd(5,10)=5, gcd-sum = 15×5 = 75

Constraints

1 ≤ nums.length ≤ 10³
1 ≤ k ≤ nums.length
1 ≤ nums[i] ≤ 10⁶

Visualization

Tap to expand

Asked in

G Google 15 M Microsoft 12 a Amazon 8

The key insight is that the GCD of any subarray must be a divisor of at least one element in the array. Instead of checking all O(n²) subarrays, we can group elements by potential GCD values and use efficient algorithms. Best approach uses GCD-based grouping with sliding window optimization. Time: O(n² log M), Space: O(n).

Common Approaches

✓ Memoization

⏱️ Time: N/A Space: N/A

Brute Force - Check All Subarrays

⏱️ Time: O(n³ log M) Space: O(1)

For each possible starting position, examine all subarrays of length k or more. Calculate the sum and GCD of each subarray, then compute their product to find the maximum gcd-sum.

Optimized - GCD-Based Grouping

⏱️ Time: O(n² log M) Space: O(n)

Instead of checking every subarray, we observe that the GCD of any subarray must be a divisor of at least one element in it. We can group potential subarrays by their GCD value and use sliding window techniques.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

#define MAX_N 1000
#define MAX_MEMO 500000

struct MemoEntry {
    int start;
    int end;
    long long result;
};

static struct MemoEntry memo[MAX_MEMO];
static int memo_size = 0;
static int nums[MAX_N];

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

long long getMemo(int start, int end) {
    for (int i = 0; i < memo_size; i++) {
        if (memo[i].start == start && memo[i].end == end) {
            return memo[i].result;
        }
    }
    return -1;
}

void setMemo(int start, int end, long long result) {
    if (memo_size < MAX_MEMO) {
        memo[memo_size].start = start;
        memo[memo_size].end = end;
        memo[memo_size].result = result;
        memo_size++;
    }
}

long long computeGcdSum(int start, int end) {
    long long cached = getMemo(start, end);
    if (cached != -1) {
        return cached;
    }
    
    long long sum = 0;
    long long currentGcd = nums[start];
    
    for (int i = start; i <= end; i++) {
        sum += nums[i];
        currentGcd = gcd(currentGcd, nums[i]);
    }
    
    long long result = sum * currentGcd;
    setMemo(start, end, result);
    return result;
}

long long solution(int* numsArray, int n, int k) {
    memo_size = 0;
    memcpy(nums, numsArray, n * sizeof(int));
    
    long long maxGcdSum = 0;
    
    for (int start = 0; start < n; start++) {
        for (int end = start + k - 1; end < n; end++) {
            long long gcdSum = computeGcdSum(start, end);
            if (gcdSum > maxGcdSum) {
                maxGcdSum = gcdSum;
            }
        }
    }
    
    return maxGcdSum;
}

int main() {
    char line[10000];
    
    // Read nums array
    fgets(line, sizeof(line), stdin);
    int nums[MAX_N];
    int n = 0;
    
    // Parse array manually
    char* ptr = line;
    while (*ptr && *ptr != '[') ptr++;
    if (*ptr == '[') ptr++;
    
    while (*ptr && *ptr != ']') {
        while (*ptr && (*ptr == ' ' || *ptr == ',')) ptr++;
        if (*ptr && *ptr != ']') {
            nums[n++] = strtol(ptr, &ptr, 10);
        }
    }
    
    // Read k
    fgets(line, sizeof(line), stdin);
    int k = atoi(line);
    
    long long result = solution(nums, n, k);
    printf("%lld\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

⚠ Quadratic Growth

Space Complexity

✓ Linear Space

8.5K Views

Medium Frequency

~35 min Avg. Time

245 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