最大子序列和、最小子序列和、最小正子序列和、最大子序列乘积

一、先说最大子序列和问题，四种解法，时间复杂度依次递减：

1、O(N^3)

int MaxSubsequenceSum (const int A[], int N)
{
    int ThisSum, MaxSum = 0; 
    
    for(int i = 0; i != N; ++i)
        for(int j = i; j != N; ++j){
            ThisSum = 0;
            for(int k = i; k != j; ++k)
                ThisSum += A[k];
            if(MaxSum < ThisSum)
                MaxSum = ThisSum;
        }
    return MaxSum;
}

2、O(N^2)

int MaxSubsequenceSum (const int A[], int N)
{
    int ThisSum, MaxSum = 0; 
    
    for(int i = 0; i != N; ++i){ 
        ThisSum = 0;
        for(int j = i; j != N; ++j){
            ThisSum += A[j];
            if(MaxSum < ThisSum)
                MaxSum = ThisSum;
        }
    }
    return MaxSum;
}

3、O(N*logN)--分治递归--假设N是偶数

int Max3(int a, int b, int c)
{
    int max;
    max = a > b ? a : b;
    max = max > c ? max : c;
    
    return max; 
}

static int MaxSubSum (const int A[], int Left, int Right)//Left左边界(0) Right右边界(N-1) 
{
    int MaxLeftSum, MaxRightSum;
    int MaxLeftBorderSum, MaxRightBorderSum;
    int LeftBorderSum, RightBorderSum;
    int Mid;
    
    if(Left == Right)
        if(A[Left] > 0)
            return A[Left];
        else
            return 0;
    
    Mid = (Left + Right) / 2;
    MaxLeftSum = MaxSubSum(A, Left, Mid);      //左侧递归
    MaxRightSum = MaxSubSum(A, Mid+1, Right);  //右侧递归 
    
    MaxLeftBorderSum = 0; LeftBorderSum = 0;   //相比于第二种算法，去掉一个循环，每次分一半来求解最大值 
    for(int i = Mid; i != Left-1; --i){
        LeftBorderSum += A[i];
        if(LeftBorderSum > MaxLeftBorderSum)
            MaxLeftBorderSum = LeftBorderSum;
    }
    
    MaxRightBorderSum = 0; RightBorderSum = 0;
    for(int i = Mid+1; i != Right+1; ++i){
        RightBorderSum += A[i];
        if(RightBorderSum > MaxRightBorderSum)
            MaxRightBorderSum = RightBorderSum;
    }
    
    return Max3(RightBorderSum, MaxRightSum,        // 比较左侧最大值，右侧最大值和左右相加最大值 
            MaxLeftBorderSum+MaxRightBorderSum);
}

4、O(N)

int MaxSubsequenceSum (const int A[], int N)
{
    int ThisSum, MaxSum;
    ThisSum = MaxSum = 0; 
    
    for(int i = 0; i != N; ++i){ 
        ThisSum += A[i];
        if(MaxSum < ThisSum)
            MaxSum = ThisSum;
        else if(ThisSum < 0)
            ThisSum = 0;
    }
    return MaxSum;
}

 　　该算法附带的一个优点是，它只对数据进行一次扫描，一旦A[i]被读入并处理，它就不再需要被记忆。不仅如此，在任何时刻，算法都能对它已经读入的数据给出子序列问题的正确答案。具有这种特性的算法叫联机（online）算法。仅需要常量空间并以线性时间运行的联机算法几乎是完美的算法。

二、最小子序列和O(N)

    只是改变判断条件符号的方向。

int MaxSubsequenceSum (const int A[], int N)
{
    int ThisSum, MaxSum;
    ThisSum = MaxSum = 0; 
    
    for(int i = 0; i != N; ++i){ 
        ThisSum += A[i];
        if(MaxSum > ThisSum)
            MaxSum = ThisSum;
        else if(ThisSum > 0)
            ThisSum = 0;
    }
    return MaxSum;
}

 三、最小正子序列和

感谢@windrang指出我的错误。

1、O(N^2)

for (int i = 0; i != N; ++i) {
    ThisSum = 0;
    for (int j = i; j != N; ++j) {
        ThisSum += A[j];
        if (MinSum > ThisSum && ThisSum > 0)
            MinSum = ThisSum;
    }
}

2、O(NlogN)

#include <iostream>
#include <algorithm>
#include <string.h>

struct Item {
    int value;
    int index;
};

bool cmp(Item& a, Item& b) 
{ 
    if (a.value == b.value) {
        a.index = b.index = a.index < b.index ? a.index : b.index;
    }
    return a.value < b.value;
}

int MinSubsequenceSum (const int A[], int N)
{
    int ThisSum = 0, MinSum = 0;
    Item* B = new item[N];
    
    memset(B, 0, sizeof(Item) * N);
    
    for (int i = 0; i < N; ++i) {
        B[i].index = i;
        ThisSum += A[i];
        B[i].value = ThisSum;
    }
    std::sort(B, B+N, cmp);
    
    MinSum = B[0].value > 0 ? B[0].value : 2<<29;
    
    for (int i = 1; i < N; ++i) {
        if ((B[i-1].index < B[i].index) && (B[i].value - B[i-1].value > 0) && (B[i].value - B[i-1].value < MinSum)) {
            MinSum =  B[i].value - B[i-1].value;
        }
    }
    delete[] B;
    return MinSum;
}
int main ()
{
    int A[8] = {4,-1,6,-2,-1,3,6,-2}; //  4,  0, 4,  1,  -1
    std::cout << MinSubsequenceSum(A, 8);
    return 0;
}

这里是是根据绿色夹克衫老爷的答案来写的。其中需要注意的是排序，在判断函数中，需要将相同元素值的序列合并为较小的序列。否则的话，序列(4, 0, 4, 1, -1)，得出的答案为4。

四、最大子序列乘积

DP

思路：
以元素i结尾序列提供的最大正数记做 pos, 最小负数记做 nag
a[n] 大于零时:
    pos[n] = max{pos[n-1] * a[n], a[n]}
    max_value = max{max_value, pos[n]}
    若n-1位置存在最小负数, 更新 nag[n] = nag[n-1] * a[n]
a[n] 小于零时:
    pos[n] = max{nag[n-1] * a[n], 0.0}
    max_value = max{max_value, pos[n]}
    更新 nag[n] = min{pos[n-1] * a[n], a[n]}
a[n] 等于零时:
    清空 nag[n] 与 pos[n]

代码，

#include <iostream>

inline double max(const double& a, const double& b)
{
    return (a > b) ? a : b;
}

double MaxSubsequenceProduct(double a[], int len)
{
    double Max = 0.0, pos = 0.0, old = 0.0, nag = 1.0;
    for (int i = 0; i < len; ++i) {
        if (a[i] > 1e-6) {
            pos = max(old * a[i], a[i]);
            Max = max(Max, pos);
            if (nag < -1e-6) {
                nag *= a[i];
            }
        }
        else if (a[i] < -1e-6) {
            pos = max(0.0, nag * a[i]);
            Max = max(Max, pos);
            nag = (old * a[i] > a[i]) ? a[i] : old * a[i];
        }
        else {
            nag = 1.0; pos = 0.0;
        }
        old = pos;
    }
    return Max;
}

int main()
{
    double a[7] = { -2.5, 4, 0, 3, 0.5, 8, -1 };
    std::cout << MaxSubsequenceProduct(a, 7);
    std::cin >> a[2];
    return 0;
}

出处来自木叶漂舟。