Skip to content

Latest commit

 

History

History
239 lines (210 loc) · 7.22 KB

02.06.md

File metadata and controls

239 lines (210 loc) · 7.22 KB
Raw

第七章：求连续子数组的最大和

##题目描述

输入一个整形数组，数组里有正数也有负数。 数组中连续的一个或多个整数组成一个子数组，每个子数组都有一个和。 求所有子数组的和的最大值。要求时间复杂度为O(n)。

例如输入的数组为1, -2, 3, 10, -4, 7, 2, -5，和最大的子数组为3, 10, -4, 7, 2， 因此输出为该子数组的和18。

解法一、暴力循环

求一个数组的最大子数组和，如此序列1, -2, 3, 10, -4, 7, 2, -5，我想最最直观也是最野蛮的办法便是，三个for循环三层遍历，求出数组中每一个子数组的和，最终求出这些子数组的最大的一个值。 记Sum[i, …, j]为数组A中第i个元素到第j个元素的和（其中0 <= i <= j < n），遍历所有可能的Sum[i, …, j]，那么时间复杂度为O(N^3)：

//本段代码引自编程之美
int MaxSum(int* A, int n)
{
    int maximum = -INF;
    int sum = 0;
    for (int i = 0; i < n; i++)
    {
        for (int j = i; j < n; j++)
        {
            for (int k = i; k <= j; k++)
            {
                sum += A[k];
            }
            if (sum > maximum)
                maximum = sum;

            sum = 0; //这里要记得清零，否则的话sum最终存放的是所有子数组的和。也就是编程之美上所说的bug。多谢苍狼。
        }
    }
    return maximum;
}

解法二、O(N)遍历

其实这个问题，在我之前上传的微软100题，答案V0.2版[第1-20题答案]，便直接给出了以下O(N)的算法：

//copyright@ July 2010/10/18
//updated，2011.05.25.
#include <iostream.h>

int maxSum(int* a, int n)
{
    int sum = 0;
    //其实要处理全是负数的情况，很简单，如稍后下面第3点所见，直接把这句改成："int sum=a[0]"即可
    //也可以不改，当全是负数的情况，直接返回0，也不见得不行。
    int b = 0;

    for (int i = 0; i < n; i++)
    {
        if (b < 0)
            b = a[i];
        else
            b += a[i];
        if (sum < b)
            sum = b;
    }
    return sum;
}

int main()
{
    int a[10] = {1, -2, 3, 10, -4, 7, 2, -5};
    //int a[] = {-1,-2,-3,-4};  //测试全是负数的用例
    cout << maxSum(a, 8) << endl;
    return 0;
}

/*-------------------------------------
  解释下：
  例如输入的数组为1, -2, 3, 10, -4, 7, 2, -5，
  那么最大的子数组为3, 10, -4, 7, 2，
  因此输出为该子数组的和18。

  所有的东西都在以下俩行，
  即：
  b  ：  0  1  -1  3  13   9  16  18  13
  sum：  0  1   1  3  13  13  16  18  18

  其实算法很简单，当前面的几个数，加起来后，b<0后，
  把b重新赋值，置为下一个元素，b=a[i]。
  当b>sum，则更新sum=b;
  若b<sum，则sum保持原值，不更新。。July、10/31。
  ----------------------------------*/

不少朋友看到上面的答案之后，认为上述思路2的代码，没有处理全是负数的情况，当全是负数的情况时，我们可以让程序返回0，也可以让其返回最大的那个负数，下面便是前几日重写的，修改后的处理全是负数情况（返回最大的负数）的代码：

//copyright@ July
//July、updated，2011.05.25。
#include <iostream.h>
#define n 4           //多定义了一个变量

int maxsum(int a[n])
//于此处，你能看到上述思路2代码（指针）的优势
{
    int max = a[0];       //全负情况，返回最大数
    int sum = 0;
    for (int j = 0; j < n; j++)
    {
        if (sum >= 0)    //如果加上某个元素，sum>=0的话，就加
            sum += a[j];
        else
            sum = a[j];  //如果加上某个元素，sum<0了，就不加
        if (sum > max)
            max = sum;
    }
    return max;
}

int main()
{
    int a[] = { -1, -2, -3, -4};
    cout << maxsum(a) << endl;
    return 0;
}

解法三、动态规划

DP解法的具体方程：@ flyinghearts：设sum[i] 为前i个元素中，包含第i个元素且和最大的连续子数组，result 为已找到的子数组中和最大的。对第i+1个元素有两种选择：做为新子数组的第一个元素、放入前面找到的子数组。

sum[i+1] = max(a[i+1], sum[i] + a[i+1])
result = max(result, sum[i])

问题扩展

  1. 如果数组是二维数组，同样要你求最大子数组的和列?
  2. 如果是要你求子数组的最大乘积列?
  3. 如果同时要求输出子段的开始和结束列?

Data structures and Algorithm analysis in C

下面给出《Data structures and Algorithm analysis in C》中4种实现。

//感谢网友firo
//July、2010.06.05。

//Algorithm 1:时间效率为O(n*n*n)
int MaxSubsequenceSum1(const int A[], int N)
{
    int ThisSum = 0 , MaxSum = 0, i, j, k;
    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;
}

//Algorithm 2:时间效率为O(n*n)
int MaxSubsequenceSum2(const int A[], int N)
{
    int ThisSum = 0, MaxSum = 0, i, j, k;
    for (i = 0; i < N; i++)
    {
        ThisSum = 0;
        for (j = i; j < N; j++)
        {
            ThisSum += A[j];
            if (ThisSum > MaxSum)
                MaxSum = ThisSum;
        }
    }
    return MaxSum;
}

//Algorithm 3:时间效率为O(n*log n)
//算法3的主要思想：采用二分策略，将序列分成左右两份。
//那么最长子序列有三种可能出现的情况，即
//【1】只出现在左部分.
//【2】只出现在右部分。
//【3】出现在中间，同时涉及到左右两部分。
//分情况讨论之。
static int MaxSubSum(const int A[], int Left, int Right)
{
    int MaxLeftSum, MaxRightSum;             //左、右部分最大连续子序列值。对应情况【1】、【2】
    int MaxLeftBorderSum, MaxRightBorderSum; //从中间分别到左右两侧的最大连续子序列值，对应case【3】。
    int LeftBorderSum, RightBorderSum;
    int Center, i;
    if (Left == Right)Base Case
        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;
    }
    int max1 = MaxLeftSum > MaxRightSum ? MaxLeftSum : MaxRightSum;
    int max2 = MaxLeftBorderSum + MaxRightBorderSum;
    return max1 > max2 ? max1 : max2;
}

//Algorithm 4:时间效率为O(n)
//同上述第一节中的思路3、和4。
int MaxSubsequenceSum(const 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;
}