Maximum sub circular subarray

Author: volodimyr

918.maximum_sum_circular_subarray/max_circular_subarr.py

@@ -0,0 +1,76 @@
+# 918. Maximum sub circular subarray
+# Topics: 'Array', 'Dynamic Programming', 'Queue', 'Monotonic Queue', 'Divide And Conquer'
+# Level: 'Medium'
+
+# 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.
+
+ 
+
+# Example 1:
+
+# Input: nums = [1,-2,3,-2]
+# Output: 3
+# Explanation: Subarray [3] has maximum sum 3.
+
+# Example 2:
+
+# Input: nums = [5,-3,5]
+# Output: 10
+# Explanation: Subarray [5,5] has maximum sum 5 + 5 = 10.
+
+# Example 3:
+
+# Input: nums = [-3,-2,-3]
+# Output: -2
+# Explanation: Subarray [-2] has maximum sum -2.
+
+ 
+
+# Constraints:
+
+#     n == nums.length
+#     1 <= n <= 3 * 104
+#     -3 * 104 <= nums[i] <= 3 * 104
+
+from typing import List
+
+# class Solution:
+#     def maxSubarraySumCircular(self, nums: List[int]) -> int:
+#         total = nums[0]
+#         curmax = maxsubarray = nums[0]
+#         curmin = minsubarray = nums[0]
+        
+#         for i in range(1, len(nums)):
+#             x = nums[i]
+#             curmax = max(x, curmax + x)
+#             maxsubarray = max(maxsubarray, curmax)
+#             curmin = min(x, curmin + x)
+#             minsubarray = min(minsubarray, curmin)
+#             total += x
+#         if maxsubarray < 0:
+#             return maxsubarray
+#         return max(maxsubarray, (total - minsubarray))
+    
+
+# O(n**2)
+class Solution:
+    def maxSubarraySumCircular(self, nums: List[int]) -> int:
+        length = len(nums)
+        maxsubarray = 0
+        for start in range (length):
+            id = start
+            curmax = 0
+            while True:
+                curmax += nums[id]
+                curmax = max(curmax, 0)
+                maxsubarray = max(maxsubarray, curmax)
+                id = (id+1)%length
+                if id == start:
+                    break
+        if maxsubarray == 0:
+            maxsubarray = max(nums)
+        return maxsubarray

918.maximum_sum_circular_subarray/test_max_circular_subarr.py

@@ -0,0 +1,49 @@
+from max_circular_subarr import Solution
+
+def test_maxSubarraySumCircular():
+    solution = Solution()
+    
+    # Example 1: Simple case, max is single element
+    assert solution.maxSubarraySumCircular([1, -2, 3, -2]) == 3
+    
+    # Example 2: Wrapping case - classic circular advantage
+    assert solution.maxSubarraySumCircular([5, -3, 5]) == 10
+    
+    # Example 3: All negative numbers
+    assert solution.maxSubarraySumCircular([-3, -2, -3]) == -2
+    
+    # Single element
+    assert solution.maxSubarraySumCircular([5]) == 5
+    assert solution.maxSubarraySumCircular([-5]) == -5
+    
+    # Two elements
+    assert solution.maxSubarraySumCircular([1, 2]) == 3
+    assert solution.maxSubarraySumCircular([-1, -2]) == -1
+    
+    # All positive numbers - should take entire array
+    assert solution.maxSubarraySumCircular([1, 2, 3, 4]) == 10
+    
+    # Wrapping gives better result than non-wrapping
+    assert solution.maxSubarraySumCircular([8, -1, -1, -1, 8]) == 16  # Take both 8s
+    
+    # Non-wrapping is better
+    assert solution.maxSubarraySumCircular([1, -2, 3, -2, 5]) == 7  # [3, -2, 5]
+    
+    # Mix of positive and negative
+    assert solution.maxSubarraySumCircular([3, -1, 2, -1]) == 4  # Entire array
+    assert solution.maxSubarraySumCircular([3, -2, 2, -3]) == 3  # Either single 3 or [2, -3, 3]
+    
+    # Large positive at ends, negative in middle
+    assert solution.maxSubarraySumCircular([5, -3, 5, -3, 5]) == 12  # Wrap around
+    
+    # Edge case: zeros
+    assert solution.maxSubarraySumCircular([0, 0, 0]) == 0
+    assert solution.maxSubarraySumCircular([-1, 0, -1]) == 0
+    
+    # Large array pattern
+    assert solution.maxSubarraySumCircular([1, -1, 1, -1, 1]) == 2  # Wrapping
+    
+    print("All tests passed!")
+
+if __name__ == "__main__":
+    test_maxSubarraySumCircular()