最大子段和或称为最大部分和(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;
}