求数组的子数组之和的最大值 ._找出一个整数数组中子数组之和的最大值,例如:数组[1, -2, 3, 5, -1],返回8(因为符-优快云博客

转自：http://blog.youkuaiyun.com/v_JULY_v/article/details/6444021

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

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

分析：
1、求一个数组的最大子数组和，如此序列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）：

[cpp] view plain copy print ?

//本段代码引自编程之美
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;
}
}
return maximum;
}

//本段代码引自编程之美
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;
   }
}
return maximum;
}

2、现在给出O（N）时间复杂度的算法：

[cpp] view plain copy print ?

#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保持原值，不更新。。

#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保持原值，不更新。。

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

[cpp] view plain copy print ?

#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;
}

#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;  
}

4、DP解法的具体方程设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.15）
2、如果是要你求子数组的最大乘积列?
3、如果同时要求输出子段的开始和结束列?

附：

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

[cpp] view plain copy print ?