最大子序列和问题

#include <iostream>
#include <ctime>
using namespace std;

/*    最大子序列和问题求解
 *    给定数A1, A2, ..., An，求第i个到第j个累积和的最大值。
 *    如果所有整数均为负数，则最大子序列和为0
 */

/*
 *    方法1：穷举式地尝试所有的可能
 */
int maxSubsequenceSum_1(const int A[], int N) {
    int thisSum, maxSum, i, j, k;
    maxSum = 0;
    for(i = 0; i < N; i++)
        for(j = i; j < N; j++) {
            thisSum = 0;
            for(k = i; k <= j; k++)        //    出现大量不必要的计算，被过分地耗时
                thisSum += A[k];
            if(thisSum > maxSum)
                maxSum = thisSum;
        }
    return maxSum;
}    //时间复杂度为O(N3)

int maxSubsequenceSum_2(const int A[], int N) {
    int thisSum, maxSum, i, j;
    maxSum = 0;
    for(i = 0; i < N; i++) {
        thisSum = 0;
        for(j = i; j < N; j++) {
            thisSum += A[j];
            if(thisSum > maxSum)
                maxSum = thisSum;
        }
    }
    return maxSum;
}    //时间复杂度O(N2)

int max3(int a, int b, int c) {
    int max;
    max = a;
    if(b > max)
        max = b;
    if(c > max)
        max = c;
    return max;
}

/*    分治(divide-and-conquer)策略 - 
 *    “分”指把问题分成两个大致相等的子问题，然后递归地对它们求解
 *    “治”指将两个子问题的解合并到一起并可能再做些少量的附加工作，最后得到整个问题的解
 */
int maxSubSum(const int A[], int left, int right) {
    int maxLeftSum, maxRightSum;
    int maxLeftBorderSum, maxRightBorderSum;
    int leftBorderSum, rightBorderSum;
    int center, i;

    if(left == right) {    //    只有一个元素时
        if(A[left] > 0)
            return A[left];
        else
            return 0;
    }

    //    最大子序列和出现在数据的左半部或者右半部，递归求解
    center = (left + right) / 2;
    maxLeftSum = maxSubSum(A, left, center);
    maxRightSum = maxSubSum(A, center+1, right);

    //    最大子序列和占据左右两半部分
    //    求出前半部分的最大和(包含前半部分的最后一个元素)
    maxLeftBorderSum = 0; leftBorderSum = 0;
    for(i = center; i >= left; i--) {
        leftBorderSum += A[i];
        if(leftBorderSum > maxLeftBorderSum)
            maxLeftBorderSum = leftBorderSum;
    }
    //    求出后半部分的最大和(包含后半部分的第一个元素)
    maxRightBorderSum = 0; rightBorderSum = 0;
    for(i=center+1; i <= right; i++) {
        rightBorderSum += A[i];
        if(rightBorderSum > maxRightBorderSum)
            maxRightBorderSum = rightBorderSum;
    }

    return max3(maxLeftSum, maxRightSum, maxLeftBorderSum+maxRightBorderSum);
}

int maxSubsequenceSum_3(const int A[], int N) {
    return maxSubSum(A, 0, N-1);
}    //    时间复杂度O(NlogN)

/*    优点：只对数据进行一次扫描，一旦A[i]被读入并被处理，它就不再需要被记忆
 *    此外，在任意时刻，算法都能对它已经读入的数据给出序列问题的正确答案 - 联机算法
 */
int maxSubsequenceSum_4(int A[], int N) {
    int thisSum, maxSum, j;
    thisSum = maxSum = 0;
    for(j = 0; j < N; j++) {
        thisSum += A[j];
        if(thisSum > maxSum)
            maxSum = thisSum;
        else if(thisSum < 0)
            thisSum = 0;
    }
    return maxSum;
}    //    时间复杂度O(N)

int main() {
    time_t start, end;
    int A[] = {4, -3, 5, -2, -1, 2, 6, -2, 10, 9, -5, -2, 10, 2, -5, 3};
    int maxSum;

    start = clock();
    maxSum = maxSubsequenceSum_1(A, 16);
    cout << maxSum << endl;
    end = clock();
    cout << 1000.0 * (end - start) / CLOCKS_PER_SEC << endl;    //执行maxSubsequenceSum_1所花费的时间

    start = clock();
    maxSum = maxSubsequenceSum_2(A, 16);
    cout << maxSum << endl;
    end = clock();
    cout << 1000.0 * (end - start) / CLOCKS_PER_SEC << endl;

    start = clock();
    maxSum = maxSubsequenceSum_3(A, 16);
    cout << maxSum << endl;
    end = clock();
    cout << 1000.0 * (end - start) / CLOCKS_PER_SEC << endl;

    start = clock();
    maxSum = maxSubsequenceSum_4(A, 16);
    cout << maxSum << endl;
    end = clock();
    cout << 1000.0 * (end - start) / CLOCKS_PER_SEC << endl;

    return 0;
}

　　参考书籍《数据结构与算法分析：C语言描述》