编程之美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[n];
	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;
}