最大子序列和问题

转载自http://www.cnblogs.com/CCBB/archive/2009/04/25/1443455.html

 

问题描述：

输入一组整数，求出这组数字子序列和中最大值。也就是只要求出最大子序列的和，不必求出最大的那个序列。例如：

序列： -2 11 -4 13 -5 -2，则最大子序列和为20。

序列： -6 2 4 -7 5 3 2 -1 6 -9 10 -2，则最大子序列和为16。

 

算法一：

//穷举法，复杂度O(n^3) 

long maxSubSum1(const vector<int>& a)
{
       long maxSum = 0;
       for (int i = 0; i < a.size(); i++)
       {
              for (int j = i; j < a.size(); j++)
              {
                     long thisSum = 0;

                     for (int k = i; k <= j; k++)
                     {
                            thisSum += a[k];
                     }
                     if (thisSum > maxSum)
                            maxSum = thisSum;
              }
       }
       return maxSum;
}

这是一个 O(N^3) 的算法，算法本身很容易理解，而且很直观的感觉做了很多无用操作。例如：i = 0, j = 3时，会计算a[0] + a[1] +…+ a[3]；而当i = 0, j = 4时候又会计算a[0] + a[1] +…a[4]。

算法二：

通过撤出一个 for循环来避免三次时间。

//也是穷举法，不过减去了上面的一些不必要操作O(n^2) 

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

这是一个非常直观的穷举法（比上面的分析还有简单些），而且没有多余重复的操作，复杂度为 O(N^2) 。其中，thisSum表示a[i] + a[i+1] + … + a[j-1]。

 

 

算法三：

    对这个问题，有一个相对复杂的O(NlogN)的解法，就是使用递归。如果要是求出序列的位置的话，这将是最好的算法了（因为我们后面还会有个O(N)的算法，但是不能求出最大子序列的位置）。该方法我们采用 “分治策略”（divide-and-conquer）。

在我们例子中，最大子序列可能在三个地方出现，或者在左半部，或者在右半部，或者跨越输入数据的中部而占据左右两部分。前两种情况递归求解，第三种情况的最大和可以通过求出前半部分最大和（包含前半部分最后一个元素）以及后半部分最大和（包含后半部分的第一个元素）相加而得到。

//递归法，复杂度是O(nlogn) 

long maxSumRec(const vector<int>& a, int left, int right)
{
       if (left == right)
       {
              if (a[left] > 0)
                     return a[left];
              else
                     return 0;
       }
       int center = (left + right) / 2;
       long maxLeftSum = maxSumRec(a, left, center);
       long maxRightSum = maxSumRec(a, center+1, right);

       //求出以左边对后一个数字结尾的序列最大值
       long maxLeftBorderSum = 0, leftBorderSum = 0;
       for (int i = center; i >= left; i--)
       {
              leftBorderSum += a[i];
              if (leftBorderSum > maxLeftBorderSum)
                     maxLeftBorderSum = leftBorderSum;
       }

       //求出以右边对后一个数字结尾的序列最大值
       long maxRightBorderSum = 0, rightBorderSum = 0;
       for (int j = center+1; j <= right; j++)
       {
              rightBorderSum += a[j];
              if (rightBorderSum > maxRightBorderSum)
                     maxRightBorderSum = rightBorderSum;
       }

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

long maxSubSum3(const vector<int>& a)
{
       return maxSumRec(a, 0, a.size()-1);
}

另外max3(long,long,long)表示求三个long中的最大值：

//求出三个long中的最大值
long max3(long a, long b, long c)
{
       if (a < b)
       {
              a = b;
       }
       if (a > c)
              return a;
       else
              return c;
}

对这个算法进行分析：

T(1) = 1 

T(N) = 2T(N/2) + O(N) 

最后得出算法的复杂度为： O(NlogN) 。

 

算法四：

下面介绍一个线性的算法，这个算法是许多聪明算法的典型：运行时间是明显的，但是正确性则很不明显（不容易理解）。

//线性的算法O(N)
long maxSubSum4(const vector<int>& a)
{
       long maxSum = 0, thisSum = 0;
       for (int j = 0; j < a.size(); j++)
       {
              thisSum += a[j];
              if (thisSum > maxSum)
                     maxSum = thisSum;
              else if (thisSum < 0)
                     thisSum = 0;
       }
       return maxSum;
}

    很容易理解时间界 O(N) 是正确的，但是要是弄明白为什么正确就比较费力了。其实这个是算法二的一个改进。分析的时候也是i代表当前序列的起点，j代表当前序列的终点。如果我们不需要知道最佳子序列的位置，那么i就可以优化掉。

     重点的一个思想是：如果 a[i] 是负数那么它不可能代表最有序列的起点，因为任何包含 a[i] 的作为起点的子序列都可以通过用 a[i+1] 作为起点来改进。类似的有，任何的负的子序列不可能是最优子序列的前缀。例如说，循环中我们检测到从 a[i] 到 a[j] 的子序列是负数，那么我们就可以推进 i 。 关键的结论是我们不仅可以把i推进到i+1，而且我们实际可以把它一直推进到j+1。

    举例来说，令p是i+1到j之间的任何一个下标，由于前面假设了a[i]+…+a[j]是负数，则开始于下标p的任意子序列都不会大于在下标i并且包含从a[i]到a[p-1]的子序列对应的子序列（j是使得从下标i开始成为负数的第一个下标）。因此，把i推进到j+1是安全的，不会错过最优解。 注意的是：虽然，如果有以 a[j] 结尾的某序列和是负数就表明了这个序列中的任何一个数不可能是与 a[j] 后面的数形成的最大子序列的开头，但是并不表明 a[j] 前面的某个序列就不是最大序列， 也就是说不能确定最大子序列在a[j]前还是a[j]后，即最大子序列位置不能求出。但是能确保maxSum的值是当前最大的子序列和。这个算法还有一个有点就是，它只对数据进行一次扫描，一旦a[j]被读入处理就不需要再记忆。它是一个 联机算法 。

 

联机算法：在任意时刻算法都能够对它已读入的数据给出当前数据的解。 

 

常量空间线性时间的联机算法几乎是完美的算法。

 

附录：

程序测试：

先通过文件读写函数产生一组随机数并且读入到一个vector中：

 

//COUNT和MAX_NUM分别表示随机数个数和最大值
const long COUNT = 1000;
const int MAX_NUM = 200;

//读文件
bool readFile(vector<int>& input, string fileName)
{
       ifstream infile(fileName.c_str());
       if (!infile)
              return false;
       int s;
       while(infile>>s)
       {
              input.push_back(s);
       }
       return true;
}

//写大量随机测试数据
bool writeTestData(string fileName)
{
       ofstream outfile(fileName.c_str());
       if (!outfile)
              return false;
       srand((unsigned)time(NULL));
       for (int i = 0; i < COUNT; i++)
       {
              if (rand() % 2 == 0)
                     outfile << rand() % MAX_NUM << '\n';
              else
                     outfile << ~(rand() % MAX_NUM) << '\n';
       }
       return true;
}

测试可得：

当COUNT = 1000的时候maxSubSum1()要等10s，后三个很快。

当COUNT = 10000的时候maxSubSum2()要等8s，后两个很快。

当COUNT = 1000000的时候maxSubSum3()要等10s，maxSubSum4()要等4s。

其实当COUNT = 1000000这个时候但是作文件读写就要很耗时了，光是in.txt就达到了4.7MB了。

而COUNT = 10000000的时候光是文件读写就要半分钟，in.txt达到了47.2MB，这时候再做maxSubSum3()和maxSubSum4()的比较，maxSubSum4()需要56s，而maxSubSum3()这时候需要85s（包括了读文件的时间）。可见数据量比较大的情况下O(NlogN)的递归算法也是可行的，并不比O(N)低很多。尤其在要求出最大子序列位置的情况下，分治递归算法体现了强大的威力。

 

程序源码：

#include
#include
#include
#include
#include
#include

using namespace std;

//COUNT和MAX_NUM分别表示随机数个数和最大值
const long COUNT = 10000;
const int MAX_NUM = 200;

//读文件
bool readFile(vector<int>& input, string fileName)
{
    ifstream infile(fileName.c_str());
    if (!infile)
        return false;
    int s;
    while(infile>>s)
    {
        input.push_back(s);
    }
    return true;
}

//写大量随机测试数据
bool writeTestData(string fileName)
{
    ofstream outfile(fileName.c_str());
    if (!outfile)
        return false;
    srand((unsigned)time(NULL));
    for (int i = 0; i < COUNT; i++)
    {
        if (rand() % 2 == 0)
            outfile << rand() % MAX_NUM << '\n';
        else
            outfile << ~(rand() % MAX_NUM) << '\n';
    }
    return true;
}

//穷举法
long maxSubSum1(const vector<int>& a)
{
    long maxSum = 0;
    for (int i = 0; i < a.size(); i++)
    {
        for (int j = i; j < a.size(); j++)
        {
            long thisSum = 0;

            for (int k = i; k <= j; k++)
            {
                thisSum += a[k];
            }
            if (thisSum > maxSum)
            maxSum = thisSum;
        }
    }
    return maxSum;
}

//也是穷举法，不过减去了上面的一些不必要操作O(n^2)
long maxSubSum2(const vector<int>& a)
{
    long maxSum = 0;
    for (int i = 0; i < a.size(); i++)
    {
        long thisSum = 0;
        for (int j = i; j < a.size(); j++)
        {
            thisSum += a[j];
            if (thisSum > maxSum)
                maxSum = thisSum;
        }
    }
    return maxSum;
}

//递归法，复杂度是O(nlogn)
long max3(long a, long b, long c)
{
    if (a < b)
    {
        a = b;
    }
    if (a > c)
        return a;
    else
    return c;
}

long maxSumRec(const vector<int>& a, int left, int right)
{
    if (left == right)
    {
        if (a[left] > 0)
            return a[left];
        else
            return 0;
    }
    int center = (left + right) / 2;
    long maxLeftSum = maxSumRec(a, left, center);
    long maxRightSum = maxSumRec(a, center+1, right);

    //求出以左边对后一个数字结尾的序列最大值
    long maxLeftBorderSum = 0, leftBorderSum = 0;
    for (int i = center; i >= left; i--)
    {
        leftBorderSum += a[i];
        if (leftBorderSum > maxLeftBorderSum)
            maxLeftBorderSum = leftBorderSum;
    }

    //求出以右边对后一个数字结尾的序列最大值
    long maxRightBorderSum = 0, rightBorderSum = 0;
    for (int j = center+1; j <= right; j++)
    {
        rightBorderSum += a[j];
        if (rightBorderSum > maxRightBorderSum)
            maxRightBorderSum = rightBorderSum;
    }

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

long maxSubSum3(const vector<int>& a)
{
    return maxSumRec(a, 0, a.size()-1);
}

//线性的算法O(N)
long maxSubSum4(const vector<int>& a)
{
    long maxSum = 0, thisSum = 0;
    for (int j = 0; j < a.size(); j++)
    {
        thisSum += a[j];
        if (thisSum > maxSum)
            maxSum = thisSum;
        else if (thisSum < 0)
            thisSum = 0;
    }
    return maxSum;
}

int main ()
{
    vector<int> input;
    /**
    if (!writeTestData("in.txt"))
    {
        cout << "写文件错误" << endl;
    }
    */

    if (readFile(input, "in.txt"))
    {
        //cout << maxSubSum1(input) << endl;
        //cout << maxSubSum2(input) << endl;
        cout << maxSubSum3(input) << endl;
        cout << maxSubSum4(input) << endl;
    }

    return 0;
}

转载于:https://blog.51cto.com/sourberry/655191