最大子段和以及最大子段和的推广二维数组（动态规划）

一、最大子段和问题

问题定义：对于给定序列a1,a2,a3……an,寻找它的某个连续子段，使得其和最大。定义所有负数的最大字段和是0，由此定义，所求的最优值是： max{ 0, a[i] };
1.最大字段和问题的简单方法（枚举的方法）
代码实现：

int Summax1(int a[],int n)
{
	int sum=0;
	for(int i=1;i<=n;i++)
	{
		for(int j=1;j<=n;j++)
		{
			int thissum=0;//循环进行一次，临时变量需要被重新赋值
			for(int k=i;k<=j;k++)//表示从i--j的字段和
			{
				thissum+=a[k];//
			}
			if(thissum>sum)//用于更新最大字段的值sum
			{
				sum=thissum;
			}
		}
	}
	return sum;
}

2.容易发现上述方法的时间复杂度是：n^3,对于上述方法改进的，容易发现最里边的一层循环可以利用次外层的循环代替，进而将是将时间复杂度变为 n^2.
代码实现：

//一般方法改进时间复杂度是n*n

int Summax2(int a[],int n)
{
	int sum=0;
	for(int i=1;i<=n;i++)
	{
		int thissum=0;
		for(int j=i;j<=n;j++)
		{
			thissum+=a[j];
		    if(thissum>sum)
		    {
			    sum=thissum;
		    }
        }
	}
	return sum;
}

3.最大子段和的分治算法求解
针对最大子段和的问题结构可以分为前半部分和后半部分，最终将每部分的结果合并就可以得到我们想要的结果。具体的情形可以分为以下三种情况：
（1）a[1:n]的最大子段和与a[1:n/2]的最大子段和相同；
（2）a[1:n]的最大子段和与a[n/2+1：n]的最大子段和相同；
（3）a[1:n]的最大字段和是前两种的结果的合并，就是最后的最优解。
代码实现：

int Summax3(int a[],int left,int right)
{
	int sum=0;
	if(left==right)
	{
		sum=a[left]>0?a[left]:0;
	}
	else
	{
		int center=(left+right)/2;
		int leftsum=Summax3(a,left,center);
		int rightsum=Summax3(a,center+1,right);
		int sl=0;
		int lefts=0;
		for(int i=center;i>=left;i--)
		{
			lefts+=a[i];
			if(lefts>sl)
				sl=lefts;
		}
		int sr=0;
		int rights=0;
		for(int j=center+1;j<=right;j++)
		{
			rights+=a[j];
			if(rights>sr)
				sr=rights;
		}
	    sum=sr+sl;
	    if(sr>sum)
		    sum = leftsum;
	    if(sl>sum)
		    sum= rightsum;
	}
	return sum;
}
//传入参数，递归求解
int Maxsum(int a[],int n)
{
	return Summax3(a,1,n);
}

4.最大子段和的动态规划算法（时间复杂度最低）
主要思路：用 t 表示一个缓存数据，用sum 表示最大数，给定一维数组，从第一个元素开始遍历，如果该元素大于零，就用t加上该元素，否则就将该元素赋值给t，（sum初始值是0），用sum和t进行比较。如果t大于sum，就将t赋值给sum。结束此次循环。用这种方法对于sum进行更新，最后返回的就是最大值。
代码实现：

//动态规划实现

int Summax(int a[],int n)//n是数组的长度
{
	int sum=0,b=0;
	for(int i=1;i<=n;i++)
	{
		if(b>0)
		{
			b+=a[i];//读取到的数字大于零继续相加
		}
		else
		{
			b=a[i];//读取到的数小于0，就将这个数赋值给b,进入下一次循环
		}
		if(b>sum)
			{
				sum=b;//对于最大值进行更新
			}
	}
	return sum;
}

一维情况下所有算法实现：

#include<iostream>
using namespace std;
const int manx=100+5;
//动态规划实现

int Summax(int a[],int n)//n是数组的长度
{
	int sum=0,b=0;
	for(int i=1;i<=n;i++)
	{
		if(b>0)
		{
			b+=a[i];//读取到的数字大于零继续相加
		}
		else
		{
			b=a[i];//读取到的数小于0，就将这个数赋值给b,进入下一次循环
		}
		if(b>sum)
			{
				sum=b;//对于最大值进行更新
			}
	}
	return sum;
}
//一般方法实现

int Summax1(int a[],int n)
{
	int sum=0;
	for(int i=1;i<=n;i++)
	{
		for(int j=1;j<=n;j++)
		{
			int thissum=0;//循环进行一次，临时变量需要被重新赋值
			for(int k=i;k<=j;k++)//表示从i--j的字段和
			{
				thissum+=a[k];//
			}
			if(thissum>sum)//用于更新最大字段的值sum
			{
				sum=thissum;
			}
		}
	}
	return sum;
}
//一般方法改进时间复杂度是n*n

int Summax2(int a[],int n)
{
	int sum=0;
	for(int i=1;i<=n;i++)
	{
		int thissum=0;
		for(int j=i;j<=n;j++)
		{
			thissum+=a[j];
		    if(thissum>sum)
		    {
			    sum=thissum;
		    }
        }
	}
	return sum;
}
//分治算法求解
int Summax3(int a[],int left,int right)
{
	int sum=0;
	if(left==right)
	{
		sum=a[left]>0?a[left]:0;
	}
	else
	{
		int center=(left+right)/2;
		int leftsum=Summax3(a,left,center);
		int rightsum=Summax3(a,center+1,right);
		int sl=0;
		int lefts=0;
		for(int i=center;i>=left;i--)
		{
			lefts+=a[i];
			if(lefts>sl)
				sl=lefts;
		}
		int sr=0;
		int rights=0;
		for(int j=center+1;j<=right;j++)
		{
			rights+=a[j];
			if(rights>sr)
				sr=rights;
		}
	    sum=sr+sl;
	    if(sr>sum)
		    sum = leftsum;
	    if(sl>sum)
		    sum= rightsum;
	}
	return sum;
}
//传入参数，递归求解
int Maxsum(int a[],int n)
{
	return Summax3(a,1,n);
}

int main(int argc, char const *argv[])
{
	int n;
	int a[manx];
	cin>>n;
	for(int i=1;i<=n;i++)
	{
		cin>>a[i];
	}
	cout<<Maxsum(a,n)<<endl;
	return 0;
}

5.一维最大子段和的推广，推广到二维数组，也就是一个矩阵的形式，即求解一个最大子矩阵的和是最大的。
解题思路：
由于是矩阵，例如：
1 2 3 4 5
-1 -2 4 5 6
4 3 2 1 7
可以按照同一列上的元素相加转化为一维数组的形式，在调用一维情况下的函数就可求解出结果。
代码实现：

#include<iostream>
using namespace std;
const int manx=100+5;
int SumMax(int a[],int n)//一维数组下的最大子段和函数
{
	int sum=0;
	int b=0;
	for(int i=1;i<=n;i++)
	{
		if(b>0)
		{
			b+=a[i];
		}
		else
		{
			b=a[i];
		}
		if(b>sum)
		{
			sum=b;
		}
	}
	return sum;
}
int SunMax2(int m,int n,int a[][manx])
{
	int sum=0;
	int b[manx];
	for(int i=1;i<=m;i++)
	{
		for(int k=1;k<=n;k++)
		{
			b[k]=0;
		}
		for(int j=i;j<=m;j++)//按行逐步进行分解
		{
			for(int k=1;k<=n;k++)
			{
				b[k]+=a[j][k];//将二维的数组简化为一维的数组
				              //再调用一维的字段和函数，进行求解。
			}
			int max=SumMax(b,n);
			if(max>sum)
			{
				sum=max;
			}
		}
	}
	return sum;
}
int main()
{
	int a[manx][manx];
	int m,n;
	cin>>m>>n;
	for(int i=1;i<=m;i++)
	{
		for(int j=1;j<=n;j++)
		{
			cin>>a[i][j];
		}
	}
	cout<<SunMax2(m,n,a)<<endl;
	return 0;
}