最大子序列问题

问题描述：给定整数A1,A2,...,A_N(可能为负数），求(A_i+...A_j)的最大值（为了方便起见，如果所有整数均为负数，则最大子序列和为0）。

一.首先给出了一个递归的算法 复杂度为O(Nlog(N))，这个方法采用一种“分治”(divide-and-conquer)策略。在我们的例子中，最大子序列和可能出现在三处。或者整个出现在输入数据的左半部，或者整个出现右半部，或者跨越输入数据的中部从而占据左右两个半部分。前两种情况递归求解。第三种情况的最大和可以通过求出前半部分的最大和（包含前半部分的最后一个元素）以及后半部分的最大和（包含后半部分的第一个元素)而得到，然后将这两个和加在一起，求出三个值的最大值：

int  maxSumRec( const  vector < int >&  a,  int  left,  int  right)
... {
    if(left==right) //base case
        if(a[left]>0)
            return a[left];
        else
            return 0;

    int center = (left + right)/2;
    int maxLeftSum = maxSumRec(a, left, center);
    int maxRightSum = maxSumRec(a, center+1, right);

    int maxLeftBorderSum = 0, leftBorderSum = 0;

    for(int i = center; i >= left; i--)
    ...{
        leftBorderSum += a[i];
        if(leftBorderSum > maxLeftBorderSum)
            maxLeftBorderSum = leftBorderSum;
    }

    int maxRightBorderSum = 0, rightBorderSum = 0;
    for(int i = center + 1; i<=right; j++)
    ...{
        rightBorderSum += a[j];
        if(rightBorderSum > maxRightBorderSum )
            maxRightBorderSum = rightBorderSum;
    }

    return std::max(maxLeftSum, std::max(maxRightSum,maxLeftBorderSum+maxRightBorderSum));
}

2、第二个算法的复杂度为O(N)

int  maxSubSum( const  vector < int >&  a)
... {
    int maxSum = 0;
    int thisSum = 0;
    for(int i = 0; i < a.size(); i++)
    ...{
        thisSum += a[i];
        if(thisSum > maxSum)
            maxSum = thisSum;
        else if( thisSum < 0)
            thisSum = 0;
    }
    return maxSum;
}

References:
Mark Allen Weiss    Data Structures and Algorithm Analysis in C++  Third Edition   

二、最大子序列乘积

/**/ /*
这个问题其实可以简化成这样：数组中找一个子序列，使得它的乘积最大；同时找一个
子序列，使得它的乘积最小（负数的情况）。虽然我们只要一个最大积，但由于负数的
存在，我们同时找这两个乘积做起来反而方便。

我们让maxCurrent表示当前最大乘积的candidate，minCurrent反之，表示当前最小乘积
的candidate。这里我用candidate这个词是因为只是可能成为新一轮的最大/最小乘积，
而maxProduct则记录到目前为止所有最大乘积candidates的最大值。

由于空集的乘积定义为1，在搜索数组前，maxCurrent,maxProduct,minCurrent都赋为1。
假设在任何时刻你已经有了maxCurrent和minCurrent这两个最大/最小乘积的candidates，
新读入数组的元素x(i)后，新的最大乘积candidate只可能是maxCurrent或者minCurrent
与x(i)的乘积中的较大者，如果x(i)<0导致maxCurrent<minCurrent，需要交换这两个
candidates的值。

当任何时候maxCurrent<1，由于1（空集）是比maxCurrent更好的candidate，所以更新
maxCurrent为1，类似的可以更新minCurrent。任何时候maxCurrent如果比最好的
maxProduct大，更新maxProduct。


*/
template  < typename Comparable >
Comparable maxprod(  const  vector < Comparable >& v)
... {
    int i;
    Comparable maxProduct = 1;
    Comparable minProduct = 1;
    Comparable maxCurrent = 1;
    Comparable minCurrent = 1;
    //Comparable t;

    for( i=0; i< v.size() ;i++)
    ...{
        maxCurrent *= v[i];
        minCurrent *= v[i];
        if(maxCurrent > maxProduct) 
            maxProduct = maxCurrent;
        if(minCurrent > maxProduct)
            maxProduct = minCurrent;
        if(maxCurrent < minProduct)
            minProduct = maxCurrent;
        if(minCurrent < minProduct)
            minProduct = minCurrent;
        if(minCurrent > maxCurrent)
            swap(maxCurrent,minCurrent);
        if(maxCurrent<1)
            maxCurrent = 1;
        //if(minCurrent>1)
        //    minCurrent =1;
    }
    return maxProduct;
        
}