Maximum Sum Circular Subarray - Practice Coding Problems

Maximum Sum Circular Subarray - Problem

Maximum Sum Circular Subarray

You're given a circular integer array nums of length n. Your task is to find the maximum possible sum of any non-empty subarray within this circular array.

🔄 What makes it circular? The end of the array connects to the beginning - imagine the array arranged in a circle where the last element is adjacent to the first element.

Goal: Return the maximum subarray sum, considering that the subarray can either:
1. Be a regular subarray (contiguous elements without wrapping)
2. Be a circular subarray (wrapping around from end to beginning)

Important: Each element can only be used once in your subarray, and the subarray must be non-empty.

Input & Output

example_1.py — Mixed positive and negative

$ Input: [1, -2, 3, -2]

› Output: 3

💡 Note: The maximum subarray is [3] with sum = 3. While we could form a circular subarray [3, -2, 1] = 2, the regular subarray [3] gives us the better result.

example_2.py — Circular case wins

$ Input: [5, -3, 5]

› Output: 10

💡 Note: The maximum circular subarray [5, 5] (wrapping around, skipping -3) gives sum = 10, which is better than any regular subarray like [5] = 5.

example_3.py — All negative numbers

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

› Output: -2

💡 Note: When all numbers are negative, we must pick the single largest element. The circular approach would give sum = 0 (empty array), but we need non-empty subarray, so we return -2.

Constraints

n == nums.length
1 ≤ n ≤ 3 × 10⁴
-3 × 10⁴ ≤ nums[i] ≤ 3 × 10⁴
Important: The subarray must be non-empty

Visualization

Tap to expand

Understanding the Visualization

Regular Case

Find the best continuous segment using Kadane's algorithm - like finding the best row in the theater

Circular Case

Find the worst segment and avoid it - the remaining seats (wrapping around) give us the best circular option

Compare Results

Choose between the best regular segment and the best circular segment

Handle Edge Case

If all seats are 'bad' (negative), we must still pick the least bad single seat

Key Takeaway

🎯 Key Insight: Maximum circular subarray = Total sum - Minimum subarray (but handle the all-negative edge case!)

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28 Apple 22

The optimal solution uses Kadane's algorithm twice in O(n) time. First, find the maximum regular subarray sum using standard Kadane's. Then, find the maximum circular subarray sum by calculating total_sum - minimum_subarray_sum. Return the maximum of both cases, handling the edge case where all elements are negative.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (All Possible Subarrays)	O(n³)	O(1)	Try every possible subarray, including circular ones
Kadane's Algorithm (Two Cases)	O(n)	O(1)	Apply Kadane's algorithm for regular and circular cases separately

Brute Force (All Possible Subarrays) — Algorithm Steps

For each starting position i (0 to n-1)
For each possible length j (1 to n)
Calculate sum of subarray starting at i with length j
Handle circular wrapping using modular arithmetic
Track the maximum sum found

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at position 0

Try all subarrays starting at index 0

Move to position 1

Try all subarrays starting at index 1

Continue for all positions

Repeat for every starting position

Track maximum

Keep track of the maximum sum found

Code -

solution.c — C

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

int maxSubarraySumCircular(int* nums, int n) {
    int maxSum = INT_MIN;
    
    // Try all possible subarrays
    for (int i = 0; i < n; i++) {  // Starting position
        for (int length = 1; length <= n; length++) {  // Length of subarray
            int currentSum = 0;
            for (int k = 0; k < length; k++) {
                currentSum += nums[(i + k) % n];
            }
            if (currentSum > maxSum) {
                maxSum = currentSum;
            }
        }
    }
    
    return maxSum;
}

int main() {
    int nums[] = {1, -2, 3, -2};
    int n = sizeof(nums) / sizeof(nums[0]);
    printf("%d\n", maxSubarraySumCircular(nums, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Three nested loops: starting position, length, and sum calculation

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables to track maximum sum

✓ Linear Space

68.4K Views

High Frequency

~15 min Avg. Time

1.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 (All Possible Subarrays) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler