最大子段和问题——详解（C++)

最大子段和或称为最大部分和(maximum subtotal)问题，以下简称MS。

• MS：给定一类特定的数据类型的序列：[x1,x2,x3,x4,x5,x6]，从该序列截取一段连续的子序列，如果这个子序列和满足整个序列的任意序列的最大值，我们称之为最大子段和。

   Sample：sequence：{6, -3, -4, 7, -1, 5, -3, -4, 8, -2};
   
   subSequence：6 -3、 -1 5 -3等；
   
   MS：7 -1 5 -3 -4 8
  

举例说明
例如：
则其最大字段和为：3+(−2)+5=6

暴力破解（Brute Force）：
可以从串的任意位置开始在连续的任意位置结束，一层循环控制起始位置，一层循环控制结束位置。

复杂度：O(n^2)

//迭代
#include<iostream>
#include<algorithm>

using namespace std;

const int MaxNum = 100001;
const int MinINF = -1000003;
int numn;
int sequence[MaxNum];

int main()
{
	while(cin>>numn)
	{
		sequence[0] = MinINF;
		for(int i = 1; i <= numn; ++i)
		{
			cin>>sequence[i];
		}
		for(int i = 1; i <= numn; ++i)
		{
			int temporary = 0;
			for(int j = i; j <= numn; ++j)
			{
				temporary += sequence[j];
				sequence[0] = max(sequence[0], temporary);
			}
		}
		cout<<sequence[0]<<endl;
	}
    return 0;
}

动态规划（Dynamic Programming）：

• 有暴力破解我们可以得到j这层循环本质是在求解当前位置开头的所有前缀最大和；
• 子序列递增具备连续性质
• 定义：dp[i]为能连续并到我当前位置的最大和：

令b[j]表示以位置 j 为终点的所有子区间中和最大的一个
子问题:如j为终点的最大子区间包含了位置j-1,则以j-1为终点的最大子区间必然包括在其中
如果dp[j-1] >0, 那么显然dp[j] = dp[j-1] + seq[j]，用之前最大的一个加上a[j]即可，因为seq[j]必须包含
如果dp[j-1]<=0,那么dp[j] = seq[j] ,因为既然最大，前面的负数必然不能使你更大
对于这种子问题结构和最优化问题的证明，可以参考算法导论上的“剪切法”，即如果不包括子问题的最优解，把你假设的解粘帖上去，会得出子问题的最优化矛盾.证明如下：

令seq[x,y]表示seq[x]+…+seq[y] , y>=x
假设以j为终点的最大子区间 [s, j] 包含了j-1这个位置，以j-1为终点的最大子区间[ r, j-1]并不包含其中
即假设[r,j-1]不是[s,j]的子区间
存在s使得seq[s, j-1]+a[j]为以j为终点的最大子段和,这里的 r != s
由于[r, j -1]是最优解, 所以a[s,j-1]

得到状态转移方程：dp[i] = max(seq[i], dp[i-1]+seq[i]) | 1 <= j <= n && dp[i] >= 0;

seq[i] | dp[i] < 0;

例如，若a序列为(-2,11,-4,13,-5,-2)，dp[0]=0，求其他元素如下：

（1）dp[1]=max{dp[0]+(-2),-2}=max{-2,-2}=-2

（2）dp[2]=max{dp[1]+11,11}=max{9,11}=11

（3）dp[3]=max{dp[2]+(-4),-4}=max{7,-4}=7

（4）dp[4]=max{dp[3]+13,13}=max{20,13}=20

（5）dp[5]=max{dp[4]+(-5),-5}=max{15,-5}=15

（6）dp[6]=max{dp[5]+(-2),-2}=max{13,-2}=13

其中，dp[4]=20为最大值，向前找到dp[1]小于等于0，所以由a2~a4的元素即(11,-4,13)构成最大子段和，其和为20

复杂度：O(n),由上式可以看出，如果dp[i]为负数，就没有在赋能的意义了，所以dp[i]数组可以不需要,空间复杂度：S(1)。

#include<iostream>
#include<algorithm>

using namespace std;

const int MinINF = -1000003;

int numn;
int maxnum;

int main()
{
	while(cin>>numn)
	{
		maxnum = MinINF;
		int temporary;
		int tempsum = 0;
		for(int i = 1; i <= numn; ++i)
		{
			cin>>temporary;
			if(tempsum >= 0)
			{
				tempsum += temporary;
			}
			if(tempsum < 0)
			{
				tempsum = temporary;
			}
			maxnum = max(maxnum, tempsum);
		}
		cout<<maxnum<<endl;
	}
	return 0;
}

分治（Divide and conquer）：
产生最大子段和可以由三种情况得出：

• 1）最大的子段和在序列的左边
• 2）最大的子段和在序列的右边
• 3）最大的子段和等于左边加右边

hint：合并的过程要是连续的

复杂度：T(n) = 2T(n/2) + O(n);即：O(nlgn)。

#include<iostream>
#include<algorithm>

using namespace std;

const int MaxNum = 100001;
const int MinINF = -1000003;
int numn;
int sequence[MaxNum];

int MergeMax(int x, int y, int z)
{
	x = x > y ? x : y;
	x = x > z ? x : z;
	return x;
}

int MaxSum(int left, int right)
{
	int sum = 0;
	if(left == right)
	{
		return sequence[left] >= 0 ? sequence[left] : 0;
	}
	else
	{
		int mid = (right+left)/2;
		int leftsum = MaxSum(left, mid);
		int rightsum = MaxSum(mid+1, right);
	
		int maxnum1 = MinINF;
		int tempsum1 = 0;
		for(int i = mid; i >= left; --i)
		{
			tempsum1 += sequence[i];
			if(tempsum1 > maxnum1)
				maxnum1 = tempsum1;
		}
	
		int maxnum2 = MinINF;
		int tempsum2 = 0;	
		for(int i = mid+1; i <= right; ++i)
		{
			tempsum2 += sequence[i];
			if( tempsum2> tempsum2)
				maxnum2 = tempsum2;
		}
	
		sum = maxnum1+maxnum2;
		sum = MergeMax(sum, leftsum, rightsum);
	}	
	return sum;
}

int main()
{
	while(cin>>numn)
	{
		for(int i = 0; i < numn; ++i)
		{
			cin>>sequence[i];
		}
		cout<<MaxSum(0, numn)<<endl;
	}
	return 0;
}

最大子矩阵和（Maximum subMatrix）问题：对最大子段和的升维

问题大意：给定一个矩阵，求最大值子矩阵。

我们可以对矩阵向下叠加转化为最子段和问题，即当前点为末位边角元素所有矩阵的最大和：这样就可以对行不断向下叠加操作行次求解子段最大和便得到结果。

//poj1050为例
#include<iostream>
#include<algorithm>
#include<string.h>

const int MaxNum = 101;
const int MinINF = -100003;

int dp[MaxNum];
int matrix[MaxNum][MaxNum];
int numn;
int maxnum;

using namespace std;

int main()
{
	while(cin>>numn)
	{
		for(int i = 0; i < numn; ++i)
			for(int j = 0; j < numn; ++j)
				cin>>matrix[i][j];
		maxnum = MinINF;
		for(int i = 0; i < numn; ++i)
		{
			memset(dp, 0, sizeof(dp));
			for(int j = i; j < numn; ++j)
			{
				int tempsum = 0;
				for(int k = 0; k < numn; ++k)
				{
					dp[k] += matrix[j][k];
					if(tempsum >= 0)
					{
						tempsum += dp[k];
					}
					if(tempsum < 0)
					{
						tempsum = dp[k];
					}
					maxnum = max(maxnum, tempsum);
				}
			}
		}
		cout<<maxnum<<endl;
	}
	return 0;
}