OJ Links
LEETCODE Code
A Solution
Linear sweep over
- Calculation prefix and Ai, i.e. a1 + a2 + ...... + ai
- Calculate the minimum prefix and Bi, min (A1, A2, ......, Ai)
- Ai places the end sub-segment of the maximum and Ci = Ai-Bi
- Also open a variable res, recording the minimum value can be Ci
- Time complexity of O (n)
typedef int ll;
class Solution {
public:
ll maxSubArray(vector<int>& nums) {
int sz = nums.size();
if (!sz) {
return 0;
}
ll prefix_sum = nums[0];
ll min_prefix_sum = nums[0];
ll res = nums[0];
for(int i=1; i<sz; i++) {
prefix_sum += nums[i];
res = max(res, prefix_sum- min(min_prefix_sum, 0));
min_prefix_sum = min(min_prefix_sum, prefix_sum);
}
return res;
}
};
Solution two
Dynamic Programming
- Maintenance ending ai of the largest sub-segment and Ci
- Also open a variable res, recording the minimum value can be Ci
- Time complexity of O (n)
typedef int ll;
class Solution {
public:
ll maxSubArray(vector<int>& nums) {
int sz = nums.size();
if (sz == 0) {
return 0;
}
ll res, current_max;
res = current_max = nums[0];
for (int i=1; i<sz; i++) {
current_max = max(nums[i], current_max + nums[i]);
res = max(res, current_max);
}
return res;
}
};
Solution three
Minute root treatment
- For each segment, the need to maintain
- The largest sub-segment from the left and the beginning of
- The largest sub-segment from the right and the beginning of
- And the largest sub-segment
- sum
- Time complexity of O (n)
T(n) = 2T(n/2) + O(1) = 2*2T(n/2/2) + O(1) + O(1) = 2^tT(n/(2^t)) + tO(1) = 2^t + tO(1)
2^t = n
t = logn
T(n) = O(n + logn) = O(n)
class Solution {
public:
int maxSubArray(vector<int>& nums) {
ll left_sum, right_sum, total_sum;
return maxSubArray(nums, 0, nums.size() - 1, left_sum, right_sum, total_sum);
}
private:
// 每一段需要维护
// 总和、左侧最大和、右侧最大和,最大子段和
ll maxSubArray(vector<int>& nums, int L, int R, ll &left_sum, ll &right_sum, ll &total_sum) {
if (L>R) {
return 0;
}
if (L==R) {
left_sum = right_sum = total_sum = nums[L];
return nums[L];
}
int mid = L + R >> 1;
ll left_left_sum, left_right_sum, left_total_sum;
ll right_left_sum, right_right_sum, right_total_sum;
ll left_max_sum = maxSubArray(nums, L, mid, left_left_sum, left_right_sum, left_total_sum);
ll right_max_sum = maxSubArray(nums, mid+1, R, right_left_sum, right_right_sum, right_total_sum);
left_sum = max(left_left_sum, left_total_sum + right_left_sum);
right_sum = max(right_right_sum, right_total_sum + left_right_sum);
total_sum = left_total_sum + right_total_sum;
return max(max(left_max_sum, right_max_sum), left_right_sum + right_left_sum);
}
};
For Four
Minute root treatment
- But that does not maintain a pile of data solution III
- Seeking the maximum cross each intermediate sub-segment and a linear scan time
- The time complexity of O (nlogn)
typedef int ll;
class Solution {
public:
int maxSubArray(vector<int>& nums) {
return maxSubArray(nums, 0, nums.size() - 1);
}
private:
// 每一段需要维护
// 总和、左侧最大和、右侧最大和,最大子段和
ll maxSubArray(vector<int>& nums, int L, int R) {
if (L>R) {
return 0;
}
if (L==R) {
return nums[L];
}
int mid = L + R >> 1;
ll left_max_sum = maxSubArray(nums, L, mid);
ll right_max_sum = maxSubArray(nums, mid+1, R);
ll res = max(left_max_sum, right_max_sum);
ll tmp_left = nums[mid], rec_left = nums[mid];
for (int i=mid-1; i>=L; i--) {
tmp_left += nums[i];
rec_left = max(tmp_left, rec_left);
}
ll tmp_right = nums[mid+1], rec_right = nums[mid+1];
for (int i=mid+2; i<=R; i++) {
tmp_right += nums[i];
rec_right = max(tmp_right, rec_right);
}
res = max(res, rec_left + rec_right);
return res;
}
};
Los OJ Valley test
solution | When using (ms) | Memory (MB) |
---|---|---|
One | 149 | 1.87 |
two | 150 | 1.79 |
three | 168 | 2.19 |
four | 225 | 1.82 |