Sponsored
Sponsored
The main idea is to use Kadane's Algorithm to find the maximum subarray sum for two scenarios: one, where the subarray wraps around the end and beginning of the array, and two, where it does not.
Calculate the maximum subarray sum using Kadane's algorithm in the normal way. Then calculate the minimum subarray sum using a similar technique but by negating the result. The maximum possible circular subarray sum will be the maximum value between the normal subarray sum and the total array sum minus the minimum subarray sum.
Time Complexity: O(n) — as both the applications of Kadane's algorithm are linear.
Space Complexity: O(1) — no additional space is used except for a few variables.
1#include <vector>
2#include <algorithm>
3#include <numeric>
4
5int kadane(const std::vector<int>& A) {
6 int current_max = A[0], max_so_far = A[0];
7 for (int i = 1; i < A.size(); i++) {
8 current_max = std::max(A[i], current_max + A[i]);
9 max_so_far = std::max(max_so_far, current_max);
10 }
11 return max_so_far;
12}
13
14int maxSubarraySumCircular(std::vector<int>& A) {
int sumAll = std::accumulate(A.begin(), A.end(), 0);
int max_normal = kadane(A);
for (auto& num : A) num = -num;
int max_circular = sumAll + kadane(A);
return max_circular == 0 ? max_normal : std::max(max_normal, max_circular);
}This solution utilizes C++ capabilities such as std::accumulate for array sum computation. The process involves finding the maximum normal subarray sum, altering the array for minimum subarray calculation utilizing a negated Kadane's algorithm, and in turn determining the potential maximum circular sum.
Instead of using basic Kadane's approach, we can consider computing the maximum subarray sum with additional memory for storing maximum and minimum values up to each index. This allows precise tracing of subarrays—as contiguous and potential wrap-around cases.
Time Complexity: O(n)
Space Complexity: O(1)
1 public int MaxSubarraySumCircular(int[] nums) {
int total = 0, max_sum = nums[0], min_sum = nums[0];
int cur_max = 0, cur_min = 0;
foreach (var num in nums) {
cur_max = Math.Max(cur_max + num, num);
max_sum = Math.Max(max_sum, cur_max);
cur_min = Math.Min(cur_min + num, num);
min_sum = Math.Min(min_sum, cur_min);
total += num;
}
return max_sum < 0 ? max_sum : Math.Max(max_sum, total - min_sum);
}
}The C# solution exhibits a similar dynamic strategy enhanced by .NET core capabilities. Looping through the integer list with cumulative variable updates addresses the range and structure of subarray requirements entirely.