最大子段和

最新推荐文章于 2022-11-08 20:42:51 发布

nw4869

最新推荐文章于 2022-11-08 20:42:51 发布

阅读量784

点赞数

分类专栏：贪心算法文章标签：最大字段和

贪心算法专栏收录该内容

3 篇文章 0 订阅

订阅专栏

最大子段和（动态规划、压缩内存）

#include<stdio.h>
int a[1000001];
 
int maxsum(int x[],int n);
int main()
{
  int T,n,i;
  scanf("%d",&T);
       
      do
      {
         scanf("%d",&n);
         for(i = 0 ; i < n ; ++i)
          scanf("%d",&a[i]);  
         printf("%d\n",maxsum(a,n));
                  
      }while(--T);
       
 // system("pause");
  return 0;    
}
 
int maxsum(int x[],int n)
{
   int i,b = 0,k = -10000000;
 
   for(i = 0 ; i < n ; ++i)
   {
       if(b > 0) b += x[i];//如果累加和是正数，则继续加 
       /* 
          如果b <= 0,那么一定有x[i-1]<0,x[i]待定，那么如果x[i]>= 0时，
          b=x[i]是理所当然的；如果x[i]<0呢？b=x[i]合适吗？答案是合适。
          因为下一次循环b依然小于0，肯定可以找到一个大于0的数    
           
          还有一个问题：b = x[i],那不就想当然把刚才那个字段全部舍弃了吗？
          如果刚才那个子段的子段（前几个为负数）大于0呢？但这是不可能的。
          因为一个字段的第一个数一定是个正数，因为如果第一个数是负数，
          那么b<0，会执行else，直到有个正数出现，才会开始一个子段的累加 
       */
         
       else  b = x[i];//如果累加和是负数了，就把这个值赋值给b  
             
       if(b > k) k = b;//更新最大字段和 
   }
        
   return k; 
}

问题描述：

有n个数（以下都视为整数），每个数有正有负，现在要在n个数中选取相邻的一段，使其和最大，输出最大的和。

问题分析：

看到这个问题，它是属于带“最”字的问题，其实就是一个求最优解的问题。对于这种问题的朴素算法就是枚举出每种可能，然后在其中寻找一个最优的解，然后输出。因为输出仅要求这个子段的和，因此不必再记录关于解的组成的信息。

朴素算法是用i和j表示序列i到j的子段，然后判断这个子段的和是否是最大的，是就记录。然后用k求i到j之间的和，因此是O(n^3)的算法。

int LSS_SlowEnumerate(int a[]) //最大子段和，枚举算法，O(n^3)
{
int max = 0, n = a[0], sum;

for (int i = 1; i <= n; i++)
{
   for (int j = 1; j <= n; j++)
   {
    sum = 0;                //sum 为区间 [i, j] 之间的最大和
    for (int k = i; k <= j; k++)
    {
     sum += a[k];
    }

    if (sum > max)
     max = sum;
   }
}

return max;
}

看了这个算法，我们不禁会想，有没有能更快的算法呢？毕竟O(n^3)的时间效率是很低的。答案肯定是有的，我们可以令一个数组sum，sum[i]代表了序列从1到i的和。如果要算i到j的和，只需将sum[j]减去sum[i-1]即可，这无疑可以去掉最里层的循环，从而直接调用和的信息，时间效率提高到O(n^2)。

int LSS_Enumerate(int a[]) //最大子段和，枚举算法，O(n^2)
{
int sum[101], i, n = a[0], max = -200000000, t; //sum[i] 表示 a[i] 的前 i 项和

sum[0] = 0;

for (i = 1; i <= n; i++)
{
sum[i] = sum[i - 1] + a[i];
}

for (i = 0; i <= n - 1; i++)             //枚举每个可能的子段
{
   for (int j = i + 1; j <= n; j++)
   {
    t = sum[j] - sum[i];
    if (t > max)
     max = t;
   }
}

return max;
}

上面两种算法都是朴素算法，枚举每个可能，从而找到最优的解。然而还有没有更优的解呢？答案依旧是肯定的。

我们不妨从小规模数据分析，当序列只有一个元素的时候，最大的和只有一个个可能，就是选取本身；当序列有两个元素的时候，只有三种可能，选取左边元素、选取右边元素、两个都选，这三个可能中选取一个最大的就是当前情况的最优解；对于多个元素的时候，最大的和也有三个情况，从左区间中产生、从右区间产生、左右区间各选取一段。因此不难看出，这个算法是基于分治思想的，每次二分序列，直到序列只有一个元素或者两个元素。当只有一个元素的时候就返回自身的值，有两个的时候返回3个中最大的，有多个元素的时候返回左、右、中间的最大值。因为是基于二分的思想，所以时间效率能达到O(nlgn)。

int LSS_Recursion(int a[], int l, int r) //最大子段和，分治算法，O(nlgn)
{
int m = (l + r) / 2, t = 0, L = 0, R = 0; //L为左区间能取到的最大，R为右区间能取到的最大

if (l == r) //边际条件：当区间元素只有一个的时候返回自身
return a[m];

if (r - l == 1) //边际条件：当区间元素只有两个的时候返回左、右、左右相加三者中的最大值
return Max(Max(a[l], a[r]), a[l] + a[r]);

int LMax = LSS_Recursion(a, l, m); //递归左区间
int RMax = LSS_Recursion(a, m + 1, r); //递归右区间

for (int i = m; i >= 1; i--)             //左边找一个最大的和
{
   t += a[i];
   if (t > L)
    L = t;
}

t = 0;

for (int i = m + 1; i <= r; i++)            //右边找一个最大的和
{
   t += a[i];
   if (t > R)
    R = t;
}

return Max(Max(LMax, RMax), L + R);            //返回左区间的和、右区间的和、两者连起来的和中最大的
}

有了O(nlgn)的递归算法，那还能找到O(n)线性时间的算法么？——动态规划。我们令一个数组f，f[i]表示前i个元素能组成的最大和。如果f[i-1]大于零，则不管a[i]的情况，f[i-1]都可以向正方向影响a[i]，因此可以将a[i]加在f[i-1]上。如果f[i-1]小于零，则不管a[i]再大，都会产生负影响，因此我们还不如直接令f[i]=a[i]。因此状态转移方程就在这里。我们只需在f中扫描一次，找到最大的值就是最大子段的和。

int LSS_DP(int a[]) //求最大子段和，动态规划，O(n)
{
int f[101], n = a[0], max = -200000000; //f[i]表示第 i 个数能构成的最大和， max 表示当前所有中的最大和

f[1] = a[1];

for (int i = 2; i <= n; i++)
{
   if (f[i - 1] > 0)               //如果第 i 个数后面一个数能构成的最大子段和大于 0
   {
    f[i] = f[i - 1] + a[i];             //大于就将第 i 个数加入其中
   }
   else
    f[i] = a[i];               //否则第 i 个数自己组成一个最大子序列

if (f[i] > max) //更新最大值
max = f[i];
}

return max;
}

以上四个算法，从3个不同的思想解决了最大子段和问题，不管从时间效率还是代码量来说，动态规划都是最优的，仅需要一个辅助数组f来临时存取，因此时间复杂度空间复杂度都是线性的。