编程之美2.14 求数组的子数组之和的最大值

题目：如题

分析：子数组，说明是连续的，注意和区分子序列开，子序列是可以不连续的。

求和，无需返回具体的子数组的起始位置

数组中的元素包括正数、负数、0

解法一：O(N^3)

最直观的方法，求数组A[0...n-1]的子数组之和最大值，记sum[i...j]为数组中第i个元素到第j个元素的和，0 <= i<= j<=
n，要求最大的和，只需要遍历i到j的所有的可能，取最大的和就可以了。

/*
O(N^3) algorithm
*/
int MaxSubSum1(int a[], int n){
int maxsum = 0;

for(int i = 0; i < n ; i++){
for(int j = i ; j < n ; j++){
int sum = 0;
for(int k = i ; k <= j ; k++)
sum += a[k];
if(sum > maxsum)
maxsum = sum;
}
}
return maxsum;
}

解法二：O(N^2)

/*
O(N^2) algorithm
充分利用了中间数据。
例如上一轮从a[4]加到a[8]，下一轮从a[4]加到a[9]时。
实际上可以利用上面的结果，减少重复计算。
即：以a[i]起头的最大和子序列只可能有一个。
*/
int MaxSubSum2(int a[], int n){
int maxsum = 0;

for(int i = 0; i < n ; i++) {
int sum = 0;
for(int j = i ; j < n ; j++){
sum += a[j];
if(sum > maxsum)
maxsum = sum;
}
}
return maxsum;
}

解法三：O(NlogN)

将数组分成长度相等的两段数组A[0...N/2-1]和A[N/2...N-1]，分别求出这两段的最大子段和，则原数组A[0...N-1]的最大子段和将是以下三种情况中的最大值：

1、A[0...N-1]的最大子段和 = A[0...N/2-1]的最大子段和；

2、A[0...N-1]的最大子段和 = A[N/2...N-1]的最大子段和；

3、A[0...N-1]的最大子段跨过A的中间两个元素A[N/2-1]和A[N/2].

对于1、2这两种情况是将问题规模减半的相同子问题，可以通过递归求得。

对于3来言，需要找到以A[N/2-1]结尾的最大子段 以及 以A[N/2]开头的最大子段，只需要分别从A[N/2-1]开始往前遍历一遍，以A[N/2]开始往后遍历一遍即可。

int max(int a, int b) {
return a > b ? a:b;
}
/*
O(N*logN) recursive algorithm
采用了分治和递归的思想。将一个数组分成两个数组处理。
*/
int maxSum3(int a[], int start, int end) {

//如果某边剩一个元素，如果大于0则累加，小于0则放弃
if(start == end) {
if(a[left] > 0)
return a[start];
else
return 0;
}
int mid = start + (end - start) / 2;
//左半边中子序列的最大和
int leftSum = maxSum3(a, start, mid);
//右半边中子序列的最大和
int rightSum = maxSum3(a, mid + 1, end);

//跨两边子序列的最大和，所以从middle往两边起算
int leftRightSum = 0;

//首先middle往左。一个标记最大值，一个标记临时值。
int midLeftSum = 0, midLeftTemp = 0;
for(int i = mid; i >= start; i --) {
midLeftTemp += a[i];
if(midLeftTemp > midLeftSum) {
midLeftSum = midLeftTemp;
}
}
//然后middle往右
int midRightSum = 0, midRightTemp = 0;
for(int j = mid + 1; j <= end; j ++) {
midRightTemp += a[j];
if(midRightTemp > midRightSum) {
midRightSum = midRightTemp;
}
}
leftRightSum = midLeftSum + midRightSum;

//取三者中的最大值
return  max( max(leftSum, rightSum), leftRightSum);

}

解法四：O(N)

动态规划

/*
O(N) algorithm
一个以a[0]开头的到a[i]子序列只有三种情况：
1.为负。则抛弃这个结果，从a[i+1]开始重新计算（减少了计算量）//else if
2.大于已知的最大和，记录下来。//if
3.最大和还未出现，继续累加下去。//未被以上两者匹配。
*/
int maxSum4_1(int a[], const int n) {

int maxSum = 0, tempSum = 0;
for(int i = 0; i < n; i ++) {
tempSum += a[i];
if(tempSum > maxSum) {
maxSum = tempSum;
} else if(tempSum < 0) {
tempSum = 0;
}
}
return maxSum;
}
/*
定义b[j]为数组中包含a[j]的最大连续子序列和
b[j]并不是1-j中最大的连续子序列和，只是包括a[j]的子序列的和
求b[j]中最大值，状态方程：b[j] = max{a[j], b[j-1] + a[j]};
*/
int maxSum4_2(int a[], const int n) {
int *b = new int
;
b[0] = a[0];
int maxSum = b[0];
for(int i = 1; i < n; i ++) {
b[i] = max(a[i], b[i-1] + a[i]);
if(b[i] > maxSum)
maxSum = b[i];
}
return maxSum;
}