求最大子数组的和

   这是一道考的烂的不能再烂的题目，但是依然有很多公司乐于将这样的题目作为笔试或面试题，足见其经典。

    问题是这样的：一个整数数组中的元素有正有负，在该数组中找出一个连续子数组，要求该子数组中各元素的和最大，这个子数组便被称作最大子数组。比如数组{2,4,-7,5,2,-1,2,-4,3}的最大子数组为{5,2,-1,2}，最大子数组的和为5+2-1+2=8。

    下面按照时间复杂度逐步优化的顺序依次给出这三种算法。

暴力求解法

    该方法的思想非常简单，先找出从第1个元素开始的最大子数组，而后再从第2个元素开始找出从第2个元素开始的最大子数组，依次类推，比较得出最大的子数组。

 1 /*
 2 常规方法,时间复杂度O（n*n）
 3 先从第一个元素开始向后累加，
 4 每次累加后与之前的和比较，保留最大值，
 5 再从第二个元素开始向后累加，以此类推。
 6 */
 7 int MaxSubSum1(int *arr,int len)
 8 {
 9   int i,j;
10   int MaxSum = 0;
11   //每次开始累加的起始位置的循环
12   for(i=0;i<len;i++)
13   {
14     int CurSum = 0;
15     //向后累加的循环
16     for(j=i;j<len;j++)
17     {
18       CurSum += arr[j];
19       if(CurSum > MaxSum)
20         MaxSum = CurSum;
21     }
22   }
23   return MaxSum;
24 }

很明显地可以看出，该方法的时间复杂度为O（n*n）。

分治求解法

所谓分治法，是指将一个问题分解为两个子问题，然后分而解决之。具体步骤如下：

• 先将数组分为两个等长的子数组a, b；

• 分别求出两个数组a，b的连续子数组之和；

• 还有一种情况比较容易忽略：有可能最大和的子数组跨越两个数组；

 

float maxsum3(l, u)
    if (l > u) /* zero elements */ return 0 if (l == u) /* one element */ return max(0, x[l]) m = (l + u) / 2 /* find max crossing to left */ lmax = sum = 0 for (i = m; i >= l; i--) sum += x[i] lmax = max(lmax, sum) /* find max crossing to right */ rmax = sum = 0 for i = (m, u] sum += x[i] rmax = max(rmax, sum) return max(lmax+rmax, maxsum3(l, m), maxsum3(m+1, u));

容易证明，时间复杂度为 O（nlogn）。

   

考虑将数组从中间分为两个子数组，则最大子数组必然出现在以下三种情况之一：

    1、完全位于左边的数组中。

    2、完全位于右边的数组中。

    3、跨越中点，包含左右数组中靠近中点的部分。

    递归将左右子数组再分别分成两个数组，直到子数组中只含有一个元素，退出每层递归前，返回上面三种情况中的最大值。

 1 /*
 2 求三个数中的最大值
 3 */
 4 int Max3(int a,int b,int c)
 5 {
 6   int Max = a;
 7   if(b > Max)
 8     Max = b;
 9   if(c > Max)
10     Max = c;
11   return Max;
12 }
13 
14 /*
15 次优算法，采用分治策略
16 */
17 int MaxSubSum2(int *arr,int left,int right)
18 {
19   int MaxLeftSum,MaxRightSum;    //左右边的最大和
20   int MaxLeftBorderSum,MaxRightBorderSum;    //含中间边界的左右部分最大和
21   int LeftBorderSum,RightBorderSum;    //含中间边界的左右部分当前和
22   int i,center;
23 
24   //递归到最后的基本情况
25   if(left == right)
26     if(arr[left]>0)
27       return arr[left];
28     else
29       return 0;
30 
31   //求含中间边界的左右部分的最大值
32   center = (left + right)/2;
33   MaxLeftBorderSum = 0;
34   LeftBorderSum = 0;
35   for(i=center;i>=left;i--)
36   {
37     LeftBorderSum += arr[i];
38     if(LeftBorderSum > MaxLeftBorderSum)
39       MaxLeftBorderSum = LeftBorderSum;
40   }
41   MaxRightBorderSum = 0;
42   RightBorderSum = 0;
43   for(i=center+1;i<=right;i++)
44   {
45     RightBorderSum += arr[i];
46     if(RightBorderSum > MaxRightBorderSum)
47       MaxRightBorderSum = RightBorderSum;
48   }
49 
50   //递归求左右部分最大值
51   MaxLeftSum = MaxSubSum2(arr,left,center);
52   MaxRightSum = MaxSubSum2(arr,center+1,right);
53 
54   //返回三者中的最大值
55   return Max3(MaxLeftSum,MaxRightSum,MaxLeftBorderSum+MaxRightBorderSum);
56 }
57 
58 /*
59 将分支策略实现的算法封装起来
60 */
61 int MaxSubSum2_1(int *arr,int len)
62 {
63   return MaxSubSum2(arr,0,len-1);
64 }

  设该算法的时间复杂度为T（n）,则：

T（n）= 2T（n/2）+ O（n），且T（1）= 1。

    逐步递推得到时间复杂度T（n）= O（nlogn）。

线性时间算法

    该算法在每次元素累加和小于0时，从下一个元素重新开始累加。

 1 /*
 2 最优方法，时间复杂度O（n）
 3 和最大的子序列的第一个元素肯定是正数
 4 因为元素有正有负，因此子序列的最大和一定大于0
 5 */
 6 int MaxSubSum3(int *arr,int len)
 7 {
 8   int i;
 9   int MaxSum = 0;
10   int CurSum = 0;
11   for(i=0;i<len;i++)
12   {
13     CurSum += arr[i];
14     if(CurSum > MaxSum)
15       MaxSum = CurSum;
16     //如果累加和出现小于0的情况，
17     //则和最大的子序列肯定不可能包含前面的元素，
18     //这时将累加和置0，从下个元素重新开始累加
19     if(CurSum < 0)
20       CurSum = 0;
21   }
22   return MaxSum;
23 }

 显然，该算法的时间复杂度O（n）。该算法理解起来应该不难，但是要想出来可就不容易了。另外，该算法的一个附带的有点是：它只对数据进行一次扫描，一旦元素被读入并被处理，它就不再需要被记忆。因此，如果数组在磁盘或磁带上，他就可以被顺序读入，在主存中不必存储数组的任何部分。不仅如此，在任意时刻，该算法都能对它已经读入的数据给出最大子数组（另外两种算法不具有这种特性）。具有这种特性的算法叫做联机算法。

 

动态规划：(f(i)为存储0-i子数组的最大和)

 1 #include <iostream>
 2 using namespace std;
 3 
 4 
 5 int FindSerialMaxSum(int* pData,int nLength,int* f)
 6 {
 7     f[0]=pData[0];
 8     int MaxSum=0;
 9     for(int i=1;i<nLength;i++)
10     {
11         if(f[i-1]<=0)
12         {
13             f[i]=pData[i];
14         }
15         else
16         {
17             f[i]=f[i-1]+pData[i];
18         }
19 
20         if(f[i]>MaxSum)
21             MaxSum=f[i];
22     }
23     for(int k=0;k<nLength;k++)
24     {
25         cout<<f[k]<<" ";
26     }
27     cout<<endl;
28     return MaxSum;
29 }
30 
31 int main(int argc ,char* argv[])
32 {
33     int pdata[]={1,-2,3,10,-4,7,2,-5};
34     int nLength=8;
35     int *f=new int[nLength];
36     int SerivalSum=FindSerialMaxSum(pdata,nLength,f);
37     if(SerivalSum!=0)
38         cout<<"The Serial Max Sum = "<<SerivalSum<<endl;
39     else
40         cout<<"Input error!"<<endl;
41     delete[] f;
42     system("pause");
43     return 0;
44 }

 

转载于:https://www.cnblogs.com/lou424/p/4777908.html