最大子段和问题详解（51Nod - DP动态规划基础）

N个整数组成的序列a[1],a[2],a[3],…,a[n]，求该序列如a[i]+a[i+1]+…+a[j]的连续子段和的最大值。当所给的整数均为负数时和为0。

例如：-2,11,-4,13,-5,-2，和最大的子段为：11,-4,13。和为20。

输入

   第1行：整数序列的长度N（2 <= N <= 50000)
   第2 - N + 1行：N个整数（-10^9 <= A[i] <= 10^9）
 

输出

         输出最大字段和

输入示例

 

6
-2
11
-4
13
-5
-2

输出示例

 

20

看见这个问题你的第一反应是用什么算法？ 

（1） 枚举？对，枚举是万能的！枚举什么？子数组的位置！好枚举一个开头位置i，一个结尾位置j>=i，再求a[i..j]之间所有数的和，找出最大的就可以啦。好的，时间复杂度？

（1.1）枚举i，O(n)
（1.2）枚举j，O(n)
（1.3）求和a[i..j]，O(n)

大概是这样一个计算方法：

for(int i = 1; i <= n; i++)
{
    for(int j = i; j <= n; j++)
    {
        int sum = 0;
        for(int k = i; k <= j; k++)
            sum += a[k];
            
        max = Max(max, sum);
    }
}

 

所以是O(n^3), 复杂度太高？降低一下试试看？

（2） 仍然是枚举！ 能不能在枚举的同时计算和？
（2.1）枚举i，O(n)
（2. 2）枚举j，O(n) ,这里我们发现a[i..j]的和不是a[i..j – 1]的和加上a[j]么？所以我们在这里当j增加1的时候把a[j]加到之前的结果上不就可以了么？对！所以我们毫不费力地降低了复杂度，得到了一个新地时间复杂度为O(n^2)的更快的算法。

代码如下：

#include<bits/stdc++.h>
using namespace std;
int a[50002];

int main()
{
	int n;
	long long Max=a[1];
	scanf("%d",&n);
	for(int i=1;i<=n;i++)
		scanf("%d",&a[i]);
	for(int i=1;i<=n;i++)
	{
		long long sum=0;
		for(int j=i;j<=n;j++)
		{
			sum+=a[j];
			Max=max(Max,sum);
		}
	}
	if(Max>0)
		printf("%lld\n",Max);
	else 
		printf("0\n");
	return 0;
}

是不是到极限了？远远不止！

（3）分治一下？

我们从中间切开数组，原数组的最大子段和要么是两个子数组的最大子段和（分）， 要么是跨越中心分界点的最大子段和（合）。 那么跨越中心分界点的最大子段合怎么计算呢？仍然是枚举！ 从中心点往左边找到走到哪里可以得到最大的合，再从中心点往右边检查走到哪里可以得到最大的子段合，加起来就可以了。可见原来问题之所以难，是因为我们不知道子数组从哪里开始，哪里结束，没有“着力点”，有了中心位置这个“着力点”，我们可以很轻松地通过循环线性时间找到最大子段和。

于是算法变成了

（3.1）拆分子数组分别求长度近乎一半的数组的最大子段和sum1, sum2

时间复杂度 2* T(n / 2)

（3.2）从中心点往两边分别分别找到最大的和，找到跨越中心分界点的最大子段和sum3 时间复杂度 O(n)

那么总体时间复杂度是T(n) = 2 * T(n / 2) + O(n) = O(nlogn)， 又优化了一大步，不是吗？

AC代码如下：

#include<bits/stdc++.h>
typedef long long ll;
int a[100005];
ll maxsub(ll left,ll right)
{
	int center=(left+right)/2;
	if(left==right)
	{
		if(a[left]>0)	return a[left];
		else return 0;
	}
	else
	{
		ll left_sum,right_sum;
		left_sum=maxsub(left,center);
		right_sum=maxsub(center+1,right);
		ll sum=0;
		ll max=0;
		ll right_max=0,left_max=0;
		for(int i=center;i>=left;i--)
		{
			sum+=a[i];
			if(left_max<sum)	left_max=sum;
		}
		sum=0;
		for(int i=center+1;i<=right;i++)
		{
			sum+=a[i];
			if(right_max<sum)	right_max=sum;
		}
		max=right_max+left_max;
		if(max<left_sum)	max=left_sum;
		if(max<right_sum)	max=right_sum;
		return max;
	}
}

int main()
{
	int n;
	scanf("%d",&n);
	for(int i=0;i<n;i++)
		scanf("%d",&a[i]);
	printf("%lld\n",maxsub(0,n-1));
}

还能优化吗？再想想，别放弃！

 

我们在解法（3）里需要一个“着力点”达到O(n)的子问题时间复杂度，又在解法（2）里轻易地用之前的和加上一个新的元素得到现在的和，那么“之前的和”有那么重要么？如果之前的和是负数呢？显然没用了吧？我们要一段负数的和，还不如从当前元素重新开始了吧？

再想想，如果我要选择a[j]，那么“之前的和”一定是最大的并且是正的。不然要么我把“之前的和”换成更优，要么我直接从a[j]开始，不是更好么？

动态规划大显身手。我们记录dp[i]表示以a[i]结尾的全部子段中最大的和。我们看一下刚才想到的，我取不取a[i – 1],如果取a[i – 1]则一定是取以a[i – 1]结尾的子段和中最大的一个，所以是dp[i – 1]。 那如果不取dp[i – 1]呢？那么我就只取a[i]孤零零一个好了。注意dp[i]的定义要么一定取a[i]。 那么我要么取a[i – 1]要么不取a[i -1]。 那么那种情况对dp[i]有利？ 显然取最大的嘛。所以我们有dp[i] = max(dp[i – 1] + a[i], a[i]) 其实它和dp[i] = max(dp[i – 1] , 0) + a[i]是一样的，意思是说之前能取到的最大和是正的我就要，否则我就不要！初值是什么？初值是dp[1] = a[1]，因为前面没的选了。

那么结果是什么？我们要取的最大子段和必然以某个a[i]结尾吧？那么结果就是max(dp[i])了。

这样，我们的时间复杂度是O(n)，空间复杂度也是O(n)——因为要记录dp这个数组。

#include<bits/stdc++.h>
#include<cstring>
using namespace std;
typedef long long ll;
ll a[100005];
ll dp[100005];

int main()
{
	int n;
	scanf("%d",&n);
	for(int i=1;i<=n;i++)
		scanf("%lld",&a[i]);
	memset(dp,0,sizeof(dp));
	dp[1]=a[1];
	int MAX=1;
	for(int i=2;i<=n;i++)
	{
		dp[i]=max(dp[i-1],(long long)0)+a[i];
		if(dp[i]>dp[MAX])	MAX=i;
	}
	printf("%lld\n",dp[MAX]);
}

算法达到最优了吗？ 好像是！还可以优化！我们注意到dp[i] = max(dp[i － 1]， 0) ＋ a[i]， 看它只和dp[i – 1]有关，我们为什么要把它全记录下来呢？为了求所有dp[i]的最大值？不，最大值我们也可以求一个比较一个嘛。

我们定义endmax表示以当前元素结尾的最大子段和，当加入a[i]时，我们有endmax’ = max(endmax, 0) + a[i]， 然后再顺便记录一下最大值就好了。

 

伪代码如下；（数组下标从1开始）

endmax = answer = a[1]
for i = 2 to n do
    endmax = max(endmax, 0) + a[i]
    answer = max(answer, endmax)
endfor

时间复杂度？O(n)!空间复杂度？O(1)! 简单吧？我们不仅优化了时间复杂度和空间复杂度，还使代码变得简单明了，更不容易出错。

老生常谈的问题来了。我们如何找到一个这样的子段？请看上面的为伪代码endmax = max(endmax, 0) + a[i], 对于endmax它对应的子段的结尾显然是a[i]，我们怎么知道这个子段的开头呢？ 就看它有没有被更新。也就是说如果endmax’ = endmax + a[i]则对应子段的开头就是之前的子段的开头。否则，显然endmax开头和结尾都是a[i]了，让我们来改一下伪代码：

start = 1
answerstart = asnwerend = 1
endmax = answer = a[1]
for end = 2 to n do
	if endmax > 0 then
		endmax += a[end]
	else
		endmax = a[end]
		start = end
	endif
	if endmax > answer then
		answer = endmax
		answerstart = start
		answerend = end
	endif
endfor

这里我们直接用end作为循环变量，通过更新与否决定start是否改变。

总结：通过不断优化，我们得到了一个时间复杂度为 O(n)，空间复杂度为O(1)的简单的动态规划算法。动态规划，就这么简单！优化无止境！