Maximum Sum Circular Subarray

Maximum Sum Circular Subarray - Problem

Given a circular integer array nums of length n, return the maximum possible sum of a non-empty subarray of nums.

A circular array means the end of the array connects to the beginning of the array. Formally, the next element of nums[i] is nums[(i + 1) % n] and the previous element of nums[i] is nums[(i - 1 + n) % n].

A subarray may only include each element of the fixed buffer nums at most once. Formally, for a subarray nums[i], nums[i + 1], ..., nums[j], there does not exist i <= k1, k2 <= j with k1 % n == k2 % n.

Input & Output

Example 1 — Circular Maximum

$ Input: nums = [1,-3,-2,4,-1,2]

› Output: 7

💡 Note: Maximum circular subarray is [1,4,2] (wrapping around, excluding the minimum subarray [-3,-2,-1]) with sum 1+4+2 = 7. The normal maximum subarray is [4] = 4. Since 7 > 4, we return 7.

Example 2 — Normal Maximum

$ Input: nums = [5,-3,5]

› Output: 10

💡 Note: Maximum circular subarray is [5,5] (wrapping around, skipping -3) with sum 5+5 = 10. This is better than the normal maximum subarray [5] = 5.

Example 3 — All Negative

$ Input: nums = [-3,-2,-3]

› Output: -2

💡 Note: All elements are negative, so we take the single maximum element [-2] = -2. Circular case would be 0, so we return the normal maximum.

Constraints

1 ≤ nums.length ≤ 3 × 10⁴
-3 × 10⁴ ≤ nums[i] ≤ 3 × 10⁴

Visualization

Tap to expand

Asked in

G Google 45 a Amazon 38 M Microsoft 32 f Facebook 28

The key insight is that maximum circular subarray equals total sum minus minimum subarray. We compare this with the normal maximum subarray using Kadane's algorithm. Best approach uses single pass optimization. Time: O(n), Space: O(1)

Common Approaches

✓ Brute Force

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

Generate all possible subarrays considering the circular nature by trying every starting position and every possible length. For each subarray, calculate the sum and track the maximum.

Kadane's Algorithm Approach

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

Apply Kadane's algorithm twice: once for the maximum subarray in the normal array, and once to find the maximum circular subarray by calculating total sum minus minimum subarray. Return the maximum of both cases.

Optimized Single Pass

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

Combine the calculation of maximum normal subarray, minimum subarray, and total sum in a single pass. This reduces the number of iterations while maintaining the same optimal time complexity.

Brute Force — Algorithm Steps

Iterate through each possible starting position
For each start, try all possible lengths (1 to n)
Calculate sum for each subarray considering circular indexing
Keep track of maximum sum found

Visualization

Tap to expand

Step-by-Step Walkthrough

Try All Starts

Start from each position

Try All Lengths

For each start, try all possible lengths

Find Maximum

Track the maximum sum found

Code -

solution.c — C

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

int solution(int* nums, int n) {
    int maxSum = INT_MIN;
    
    // Try all possible subarrays
    for (int start = 0; start < n; start++) {
        for (int length = 1; length <= n; length++) {
            int currentSum = 0;
            for (int i = 0; i < length; i++) {
                currentSum += nums[(start + i) % n];
            }
            if (currentSum > maxSum) {
                maxSum = currentSum;
            }
        }
    }
    
    return maxSum;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Triple nested loops: n starting positions × n lengths × n for sum calculation

⚠ Quadratic Growth

Space Complexity

O(1)

Only uses a few variables to track maximum sum

✓ Linear Space

67.5K Views

High Frequency

~25 min Avg. Time

2.8K 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 — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler