Maximum Sum Circular Subarray

Problem Statement

LeetCode #918 - Maximum Sum Circular Subarray

Solve this classic coding interview problem efficiently using multiple approaches.

What to notice first

• Understand the problem constraints and requirements.
• Consider multiple approaches with different trade-offs.
• Pattern mastery comes from knowing when to use each technique.

Examples

Input	Output	Explanation
[example1]	result1	Explanation goes here
[example2]	result2	Explanation goes here

Constraints

• Standard LeetCode constraints
• Refer to the official problem statement for exact details

Real-World Applications

Where this pattern appears

• Application 1 — describe where this is used
• Application 2 — describe where this is used
• Application 3 — describe where this is used

Complexity Comparison

Approach	Time	Space	Best When
Total - Min	O(n)	O(1)	Optimal — clever formula
Kadane Circular	O(n)	O(1)	Alternative O(n)
Brute Force	O(n²)	O(1)	Learning

Which approach should you learn first?

• Pick Total - Min for the optimal solution — it is elegant and efficient.
• Pick Kadane Circular for a pure Kadane extension.
• Pick Brute Force if you are learning from scratch.

Optimal

Total - Min

O(n) time · O(1) space

Kadane Extended

Kadane Circular

O(n) time · O(1) space

Simple to Learn

Brute Force

O(n²) time · O(1) space

Approach 1: Total - Minimum Subarray (Recommended)

★ Recommended

The maximum circular sum is either the maximum non-circular sum OR the total sum minus the minimum subarray sum.

⏱ Time O(n) Single pass 💾 Space O(1) Constant

Solution Code

Python

maximum_sum_circular_subarray_total_minus_minimum.py

from typing import List


def maximum_sum_circular_subarray_total_minus_minimum(nums: List[int]) -> int:
    """
    Maximum Sum Circular Subarray - Total Minus Minimum approach.

    Time: O(n), Space: O(1) or O(n) depending on approach
    """
    pass


if __name__ == "__main__":
    # Test cases
    pass

C++

maximum_sum_circular_subarray_total_minus_minimum.cpp

#include <iostream>
#include <vector>
#include <unordered_map>
using namespace std;

class Solution {
public:
    int maximum_sum_circular_subarray_total_minus_minimum(vector<int>& nums) {
        // Maximum Sum Circular Subarray - Total Minus Minimum approach
        return 0;
    }
};

int main() {
    return 0;
}

Java

maximum_sum_circular_subarray_total_minus_minimum.java

import java.util.*;

class Solution {
    public int maximum_sum_circular_subarray_total_minus_minimum(int[] nums) {
        // Maximum Sum Circular Subarray - Total Minus Minimum approach
        return 0;
    }

    public static void main(String[] args) {
        // Test cases
    }
}

JavaScript

maximum_sum_circular_subarray_total_minus_minimum.js

/**
 * {@param {number[]} nums}
 * {@return {number}}
 */
var maximum_sum_circular_subarrayTotalminusminimum = function(nums) {
    // Maximum Sum Circular Subarray - Total Minus Minimum approach
    return 0;
};

if (require.main === module) {
    // Test cases
}

Rust

maximum_sum_circular_subarray_total_minus_minimum.rs

pub fn maximum_sum_circular_subarray_total_minus_minimum(nums: Vec<i32>) -> i32 {
    // Maximum Sum Circular Subarray - Total Minus Minimum approach
    0
}

fn main() {
    // Test cases
}

Go

maximum_sum_circular_subarray_total_minus_minimum.go

package main

import "fmt"

func maximum_sum_circular_subarrayTotalminusminimum(nums []int) int {
    // Maximum Sum Circular Subarray - Total Minus Minimum approach
    return 0
}

func main() {
    // Test cases
}

Approach 2: Kadane’s Algorithm (Circular)

🎯 Interview Favourite

Extend Kadane’s algorithm to handle the circular case by also tracking the minimum subarray.

⏱ Time O(n) Single pass 💾 Space O(1) Constant

Solution Code

Python

maximum_sum_circular_subarray_kadane_circular.py

from typing import List


def maximum_sum_circular_subarray_kadane_circular(nums: List[int]) -> int:
    """
    Maximum Sum Circular Subarray - Kadane Circular approach.

    Time: O(n), Space: O(1) or O(n) depending on approach
    """
    pass


if __name__ == "__main__":
    # Test cases
    pass

C++

maximum_sum_circular_subarray_kadane_circular.cpp

#include <iostream>
#include <vector>
#include <unordered_map>
using namespace std;

class Solution {
public:
    int maximum_sum_circular_subarray_kadane_circular(vector<int>& nums) {
        // Maximum Sum Circular Subarray - Kadane Circular approach
        return 0;
    }
};

int main() {
    return 0;
}

Java

maximum_sum_circular_subarray_kadane_circular.java

import java.util.*;

class Solution {
    public int maximum_sum_circular_subarray_kadane_circular(int[] nums) {
        // Maximum Sum Circular Subarray - Kadane Circular approach
        return 0;
    }

    public static void main(String[] args) {
        // Test cases
    }
}

JavaScript

maximum_sum_circular_subarray_kadane_circular.js

/**
 * {@param {number[]} nums}
 * {@return {number}}
 */
var maximum_sum_circular_subarrayKadanecircular = function(nums) {
    // Maximum Sum Circular Subarray - Kadane Circular approach
    return 0;
};

if (require.main === module) {
    // Test cases
}

Rust

maximum_sum_circular_subarray_kadane_circular.rs

pub fn maximum_sum_circular_subarray_kadane_circular(nums: Vec<i32>) -> i32 {
    // Maximum Sum Circular Subarray - Kadane Circular approach
    0
}

fn main() {
    // Test cases
}

Go

maximum_sum_circular_subarray_kadane_circular.go

package main

import "fmt"

func maximum_sum_circular_subarrayKadanecircular(nums []int) int {
    // Maximum Sum Circular Subarray - Kadane Circular approach
    return 0
}

func main() {
    // Test cases
}

Approach 3: Brute Force

✓ Simple

Check all possible subarrays (including those that wrap around the circular array).

⏱ Time O(n²) All pairs 💾 Space O(1) Constant

Solution Code

Python

maximum_sum_circular_subarray_brute_force.py

from typing import List


def maximum_sum_circular_subarray_brute_force(nums: List[int]) -> int:
    """
    Maximum Sum Circular Subarray - Brute Force approach.

    Time: O(n), Space: O(1) or O(n) depending on approach
    """
    pass


if __name__ == "__main__":
    # Test cases
    pass

C++

maximum_sum_circular_subarray_brute_force.cpp

#include <iostream>
#include <vector>
#include <unordered_map>
using namespace std;

class Solution {
public:
    int maximum_sum_circular_subarray_brute_force(vector<int>& nums) {
        // Maximum Sum Circular Subarray - Brute Force approach
        return 0;
    }
};

int main() {
    return 0;
}

Java

maximum_sum_circular_subarray_brute_force.java

import java.util.*;

class Solution {
    public int maximum_sum_circular_subarray_brute_force(int[] nums) {
        // Maximum Sum Circular Subarray - Brute Force approach
        return 0;
    }

    public static void main(String[] args) {
        // Test cases
    }
}

JavaScript

maximum_sum_circular_subarray_brute_force.js

/**
 * {@param {number[]} nums}
 * {@return {number}}
 */
var maximum_sum_circular_subarrayBruteforce = function(nums) {
    // Maximum Sum Circular Subarray - Brute Force approach
    return 0;
};

if (require.main === module) {
    // Test cases
}

Rust

maximum_sum_circular_subarray_brute_force.rs

pub fn maximum_sum_circular_subarray_brute_force(nums: Vec<i32>) -> i32 {
    // Maximum Sum Circular Subarray - Brute Force approach
    0
}

fn main() {
    // Test cases
}

Go

maximum_sum_circular_subarray_brute_force.go

package main

import "fmt"

func maximum_sum_circular_subarrayBruteforce(nums []int) int {
    // Maximum Sum Circular Subarray - Brute Force approach
    return 0
}

func main() {
    // Test cases
}

Common mistakes

Watch for these pitfalls

• Mistake 1 — explain what to watch for
• Mistake 2 — explain what to watch for
• Mistake 3 — explain what to watch for

Related Problems

• Two Sum ↗ Easy #1
• Contains Duplicate ↗ Easy #217

Interview Tips

Key discussion points

• Trade-offs between different approaches
• Edge cases to consider
• Possible follow-up questions
• How to extend the solution