最大子段和

最新推荐文章于 2022-06-22 21:01:32 发布
最新推荐文章于 2022-06-22 21:01:32 发布
阅读量789 收藏 3
点赞数
分类专栏： Algorithms Implementation
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jinghuaboy/article/details/39755441
版权

参考资料：《计算机算法设计与分析》第3版：Page59-64，王晓东 著

一、问题描述：

给定由n个整数（可能为负整数）组成的序列a1, a2, ..., an，求该序列的形如(s(i,j)=ai + ai+1 + ... aj, 1<=i<=j<=n)的子段和的最大值。当所有整数均为负整数时定义其最大子段和为0。最优值为：max{0, max{s(i,j), 1<=i<=j<=n}}。

二、简单算法：

用数组a[]，存储给定的n个整数a1, a2, ..., an。

int max_sum(int n,int *a,int &besti,int &bestj){
	int sum=0;
	besti=bestj=-1;
	for(int i=1;i<=n;++i){
		for(int j=i;j<=n;++j){
			int this_sum=0;
			for(int k=i;k<=j;++k){
				this_sum+=a[k];
			}
			if(this_sum>sum){
				sum=this_sum;
				besti=i;
				bestj=j;
			}
		}
	}
	return sum;
}
其中算法时间复杂度为O(n^3)。事实上，s(i,j)=s(i,j-1)+a j，故可以将最内层循环省去，避免重复计算，改进算法： 

int max_sum_optimize1(int n,int *a,int &besti,int &bestj){
	int sum=0;
	besti=bestj=-1;
	for(int i=1;i<=n;++i){
		int this_sum=0;
		for(int j=i;j<=n;++j){
			this_sum+=a[j];
			if(this_sum>sum){
				sum=this_sum;
				besti=i;
				bestj=j;
			}
		}
	}
	return sum;
}
改进后算法时间复杂度为O(n^2)：算法设计技巧上的改进，充分利用已经得到的结果，避免重复计算，节省时间。

三、分治算法：

对最大子段和问题的本身结构，还可以从算法设计的策略上对上述O(n^2)计算时间的算法加以更深刻的改进。从问题的解的结果上可以看出，它适合用分治法求解。将序列a[1:n]，分为长度相当的两段a[1:n/2]和a[n/2+1:n]，分别求出这两个子段的最大子段和，则序列a[1:n]的最大子段和有三种情形：

(1). a[1:n]的最大子段和与a[1:n/2]的最大子段和相同；

(2). a[1:n]的最大子段和与a[n/2+1:n]的最大子段和相同；

(3). a[1:n]的最大子段和为s(i,j), 1<=i<=n/2, n/2+1<=j<=n；

对(1)、(2)可递归求解；对(3)必有a[n/2]和a[n/2+1]在最优子序列中，故在a[1:n/2]中可计算s1=max{0, max{s(i,n/2), 1<=i<=n/2}}，并在在a[n/2+1:n]中可计算s2=max{0, max{s(n/2+1,j), n/2+1<=j<=n}}，则s1+s2即为(3)时的最优值。故最大子段和的分治算法如下：

int max_sum_dac(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 left_sum=max_sum_dac(a,left,center);
		int right_sum=max_sum_dac(a,center+1,right);
		int s1=0,s2=0,temp=0;
		for(int i=center;i>=left;--i){
			temp+=a[i];
			if(temp>s1){
				s1=temp;
			}
		}
		temp=0;
		for(int i=center+1;i<=right;++i){
			temp+=a[i];
			if(temp>s2){
				s2=temp;
			}
		}
		sum=s1+s2;
		if(sum<left_sum){
			sum=left_sum;
		}
		if(sum<right_sum){
			sum=right_sum;
		}	
	}
	return sum;
}

int max_sum_optimize2(int n,int *a){
	return max_sum_dac(a,1,n);
}

此算法时间复杂度为O(nlogn)。

四、动态规划算法：

若记b[j]=max{s(i,j), 1<=i<=j}，1<=j<=n，则所求最大子段和为：max{b[j], 1<=j<=n}。由b[j]的定义，当b[j-1]>0时b[j]=b[j-1]+a[j]，否则b[j]=a[j]。由此，可得：b[j]=max{b[j-1]+a[j], a[j]}, 1<=j<=n。

int max_sum_optimize3(int n,int *a){
	int sum=0,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;
}
上述算法时间复杂度为O(n)，空间复杂度为O(n)（存放数组a[]）。

五、推广1-最大子矩阵和：

给定一个m行n列的整数矩阵A，试求矩阵A的一个子矩阵，使其各元素之和为最大。最大子矩阵和是最大子段和问题向二维的推广。用二维数组a[1:m][1:n]表示矩阵A。子数组a[i1:i2][j1:j2]表示左上角和右下角行列左边分别为(i1,j1)、(i2,j2)的子矩阵，其各元素之和记为：

s(i1,i2,j1,j2)=(a[i1][j1]+a[i1+1][j1]+...+a[i2][j1])+(a[i1][j1+1]+a[i1+1][j1+1]+...+a[i2][j1+1])+...+(a[i1][j2]+a[i1+1][j2]+...+a[i2][j2])

最大子矩阵和问题的最优值为：max{s(i1,i2,j1,j2), 1<=i1<=i2<=m, 1<=j1<=j2<=n}。直接枚举法时间复杂度为O(m^2 * n^2)。但有：

max{s(i1,i2,j1,j2), 1<=i1<=i2<=m, 1<=j1<=j2<=n}=max{max{s(i1,i2,j1,j2), 1<=j1<=j2<=n}, 1<=i1<=i2<=m}}=max{t(i1,i2), 1<=i1<=i2<=m}

其中：t(i1,i2)=max{s(i1,i2,j1,j2), 1<=j1<=j2<=n}。设b[j]=a[i1][j]+a[i1+1][j]+...+a[i2][j]，则t(i1,i2)=max{b[j1]+b[j1+1]+...+b[j2], 1<=j1<=j2<=n}，此问题即为一维最大子段和问题。故借助一维最大子段和问题的动态规划算法max_sum_optimize3，可设计出最大子矩阵和的动态规划算法max_sum2如下：

int max_sum2(int m,int n,int **a){
	int sum=0;
	int *b=new int[n+1];
	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 temp=max_sum_optimize3(n,b);
			if(temp>sum){
				sum=temp;
			}
		}
	}
	return sum;
}

此算法的时间复杂度为O(m^2 * n)。

六、推广2-最大m子段和问题：

给定由n个整数（可能为负整数）组成的序列a1, a2, ..., an，以及一个正整数m且1<=m<=n，要求确定序列a1, a2, ..., an的m个不相交子段，使这m个子段的总和达到最大。最大m子段和是最大子段和问题在子段个数上的推广。

设b(i,j)表示数组a的前j项中i个子段和的最大值，且第i个子段含a[j]，1<=i<=m, i<=j<=n，则所求的最优值为：max{b(i,j), m<=j<=n}。计算b(i,j)的递归式为：b(i,j)=max{b(i,j-1)+a[j], max{b(i-1,t)+a[j], i-1<=t<j}}, 1<=i<=m, i<=j<=n。其中，b(i,j-1)+a[j]表示第i个子段含a[j-1]，max{b(i-1,t)+a[j], i-1<=t<j}表示第i个子段仅含a[j]。初始值，b(0,j)=0, 1<=j<=n; b(i,0)=0, 1<=i<=m。最大m子段和问题的动态规划算法如下：

int max_sum_m(int m,int n,int *a){
	if(n<m||m<1){
		return 0;
	}
	int **b=new int*[m+1];
	for(int i=0;i<=m;++i){
		b[i]=new int[n+1];
	}
	for(int i=0;i<=m;++i){
		b[i][0]=0;
	}
	for(int j=1;j<=n;++j){
		b[0][j]=0;
	}
	for(int i=1;i<=m;++i){
		b[i][i]=b[i-1][i-1]+a[i];
		for(int j=i+1;j<=n;++j){
			b[i][j]=b[i][j-1]+a[j];
			for(int k=i-1;k<j;++k){
				if(b[i][j]<b[i-1][k]+a[j]){
					b[i][j]=b[i-1][k]+a[j];
				}
			}
		}
	}
	int sum=0;
	for(int j=m;j<=n;++j){
		if(sum<b[m][j]){
			sum=b[m][j];
		}
	}

	for(int i=0;i<=m;++i){
		delete[] b[i];
	}
	delete[] b;
	return sum;
}

此时算法时间复杂度为O(mn^2)，空间复杂度为O(mn)。由b(i,j)的定义式可知，在计算b(i,j)时只用到b(i-1,t), i-1<=t<j和b(i,j-1)：故算法中只需保存数组b的当前行，而不必存储整个数组；max{b(i-1,t)+a[j], i-1<=t<j的值可以在计算第b(i-1,j)时预先计算并保存起来，计算b(i,j)时不必重新计算，节省了计算时间和空间；另外，最后要求max{b(m,j), m<=j<=n}，故在求b(i,j), 1<=i<=m时，只需求b(i,t), i<=t<=n-m+i，而b(i,t), n-m+i+1<=t<=n不必计算。改进后算法如下：

int max_sum_m_optimize(int m,int n,int *a){
	if(n<m||m<1){
		return 0;
	}
	int *b=new int[n+1];
	int *c=new int[n+1];
	for(int j=0;j<=n-m;++j){
		c[j]=0;
	}
	b[0]=0;
	for(int i=1;i<=m;++i){
		b[i]=b[i-1]+a[i];
		int max=b[i];
		for(int j=i+1;j<=n-m+i;++j){
			b[j]=b[j-1]>c[j-1]?b[j-1]+a[j]:c[j-1]+a[j];
			c[j-1]=max;
			if(max<b[j]){
				max=b[j];
			}
		}
		c[n-m+i]=max;
	}
	int sum=0;
	for(int j=m;j<=n;++j){
		if(sum<b[j]){
			sum=b[j];
		}
	}
	return sum;
}

此时，算法复杂度为O(m(n-m))，空间复杂度为O(n)，当m或(n-m)为常数时，算法复杂度为O(n)，空间复杂度为O(n)。

七、测试代码：

#include<cstdio>
#include<cstdlib>
#include<ctime>
#define random(x) (rand()%(x)-(x)/2)

int max_sum(int n,int *a,int &besti,int &bestj);
int max_sum_optimize1(int n,int *a,int &besti,int &bestj);
int max_sum_dac(int *a,int left,int right);
int max_sum_optimize2(int n,int *a);
int max_sum_optimize3(int n,int *a);
int max_sum2(int m,int n,int **a);
int max_sum_m(int m,int n,int *a);
int max_sum_m_optimize(int m,int n,int *a);

int main(int argc,char *argv[]){
	const int SIZE=20;
	srand(time(0));

	int a1[SIZE+1];
	for(int i=1;i<=SIZE;++i){
		a1[i]=random(101);
		printf("%d,",a1[i]);
	}
	printf("\n");
	int besti,bestj,sum;
	sum=max_sum(SIZE,a1,besti,bestj);
	printf("%d,%d,%d\n",sum,besti,bestj);
	sum=max_sum_optimize1(SIZE,a1,besti,bestj);
	printf("%d,%d,%d\n",sum,besti,bestj);
	sum=max_sum_optimize2(SIZE,a1);
	printf("%d\n",sum);
	sum=max_sum_optimize3(SIZE,a1);
	printf("%d\n\n",sum);

	sum=max_sum_m(1,SIZE,a1);
	printf("%d\n",sum);
	sum=max_sum_m(SIZE/3,SIZE,a1);
	printf("%d\n",sum);
	sum=max_sum_m(SIZE/2,SIZE,a1);
	printf("%d\n",sum);
	sum=max_sum_m(SIZE,SIZE,a1);
	printf("%d\n\n",sum);

	sum=max_sum_m_optimize(1,SIZE,a1);
	printf("%d\n",sum);
	sum=max_sum_m_optimize(SIZE/3,SIZE,a1);
	printf("%d\n",sum);
	sum=max_sum_m_optimize(SIZE/2,SIZE,a1);
	printf("%d\n",sum);
	sum=max_sum_m_optimize(SIZE,SIZE,a1);
	printf("%d\n\n",sum);

	int **a2;
	a2=new int*[SIZE+1];
	for(int i=1;i<=SIZE;++i){
		a2[i]=new int[SIZE+1];
	}
	for(int i=1;i<=SIZE;++i){
		for(int j=1;j<=SIZE;++j){
			a2[i][j]=random(101);
		}
	}
	sum=max_sum_m_optimize(1,SIZE,a2[1]);
	printf("%d\n",sum);
	sum=max_sum_optimize3(SIZE,a2[1]);
	printf("%d\n\n",sum);
	sum=max_sum2(1,SIZE,a2);
	printf("%d\n",sum);
	sum=max_sum2(SIZE/3,SIZE,a2);
	printf("%d\n",sum);
	sum=max_sum2(SIZE/2,SIZE,a2);
	printf("%d\n",sum);
	sum=max_sum2(SIZE,SIZE,a2);
	printf("%d\n",sum);
	for(int i=1;i<=SIZE;++i){
		delete[] a2[i];
	}
	delete[] a2;
	
	return 0;
}

jinghuaboy
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
动态规划之最大子段和问题
喵头鹰的博客
05-31 2万+
问题描述：最大子段和问题是将一个n个整数的序列a[1]，a[2]….a[n]中字段a[first]….a[last]之和，(1<=first<=last<=n)求这些子段和中最大的。 例如（a[1],a[2],a[3],a[4],a[5],a[6]）=(-2,11,-4,13,-5,-2)时，最大子段和为20，子段为a[2],a[3],a[4]。求解方法：如果不会算法，那就用时间复杂度为O(n^3
最大子串和
王 杰的专栏
07-06 1554
#include int main() { int t,n,x,i,j,sum,max; scanf("%d",&t); for(i=1;i<=t;i++){ scanf("%d",&n); max=-101; sum=0; for(j=1;j<=n;j++){ scanf("%d",&
最大子段和问题（分治法和动态规划）
qq_41199831的博客
05-25 5323
什么是最大子段和，通俗点讲： 最大子段和就是给了一些数，然后你从中找了几个连续的数，这组连续的数的和比任意一组连续的数的和都大，那么你找的这几个连续的数的和就是这些数的最大子段和。 通俗的听不懂你就看这里： 给定由n个整数（可能为负整数）组成的序列,...,求该序列形如的子段和的最大值。当所有整数均为负整数时定义其最大子段和0。依此定义，所求的最优值为：。例如，当...
7-5 最大子矩阵和问题
qq_53843555的博客
06-22 1505
最大子矩阵和问题
最大的子矩阵问题
much efforts, much luck
06-18 1064
1、全为1的最大的子矩阵 在一个二维0 1矩阵中找到全为1的最大正方形，返回其边长。 输入： 1 0 1 0 0 1 0 1 1 1 1 1 1 1 1 1 0 0 1 0 输出：2 思路：动态规划，构造一个等大小的dp[n][m]矩阵，dp[i][j]表示以matrix[i][j]为右下角的全1正方形的边长。初始化dp[i][0]和dp[0][j]分别为matrix[i][0]和matrix[0][j]，因为以边缘这一行一列中的点为右下角的全1正方形边长只有0和1两种情况，分别由他们本身是0还是1
最大子段和（顺序求和+比较、分治策略、动态规划）
Linger_stu的博客
04-08 571
1.顺序求和+比较
分治法求最大子段和的问题
04-14
1．用分治算法求解最大子段和问题。要求算法的时间复杂度不超过O(nlogn)。 最大子段和问题描述：给定由n个整数（可能为负整数）组成的序列a1, a2,…, an, 求该序列形如的子段和的最大值。当所有整数均为负整数时...
关于动态规划求最大子段和的Java代码写法
07-02
关于动态规划求最大子段和的Java代码写法 本文主要讲述了使用 Java 语言实现动态规划算法来求最大子段和的代码写法。动态规划是一种非常重要的算法设计技术，它可以解决许多复杂的问题。 首先，我们需要了解什么是...
动态规划策略求解最大子段和问题
04-14
最大子段和问题，可参考《算法设计与分析》讲义中关于用动态规划策略求解最大子段和问题的思想设计动态规划算法。本算法用户需要输入元素个数n，及n个整数。程序应该给出良好的用户界面，输出最大子段相关信息，包括...
最大子矩阵【最大连续子串和的衍生】
马里奥的专栏
03-19 833
最大和 时间限制：1000 ms  |  内存限制：65535 KB 难度：5 描述 给定一个由整数组成二维矩阵（r*c），现在需要找出它的一个子矩阵，使得这个子矩阵内的所有元素之和最大，并把这个子矩阵称为最大子矩阵。  例子： 0 -2 -7 0  9 2 -6 2  -4 1 -4 1  -1 8 0 -2  其最大子矩阵为： 9 2 
【算法设计与分析】最大子段和问题
拾年之璐
04-30 6396
说明：这是武汉理工大学计算机学院【算法设计与分析】课程的第二次实验第一题：最大子段和问题 >>点击查看WUTer计算机专业实验汇总 谨记：纸上得来终觉浅，绝知此事要躬行。 一、实验题目： 给定由n个整数组成的序列(……)，求该序列形如的子段和的最大值，当所有整数均为负整数时，其最大子段和为0。 二、实验要求： （1）分别用蛮力法、分治法和动态规划法设计最大子段和问题的...
最大子段和的简单、分治与动态规划解法
Dreamer Thinker Doer
05-17 610
//最大子段和_简单解法 package wkx; import java.io.IOException; public class Test { private static int MaxSum(int[] a,Point p) { int len =a.length; int sum=0; int max=Integer.MIN_VALUE; for(int i=
最大子矩阵问题
YCH1035235541的专栏
12-05 1731
最大和 时间限制：1000 ms  |  内存限制：65535 KB 难度：5 描述 给定一个由整数组成二维矩阵（r*c），现在需要找出它的一个子矩阵，使得这个子矩阵内的所有元素之和最大，并把这个子矩阵称为最大子矩阵。 例子：0 -2 -7 0 9 2 -6 2 -4 1 -4 1 -1 8 0 -2 其最大子矩阵为： 9 2 -4 1 -1 8 其元素总和为15。 
动态规划-最大子段和
哈哈哈哈哈哈哈哈的博客
04-13 1133
1.题目描述 2.算法思想 方法1：枚举 将所有的(i,j)对找出来，计算对应子段和，最后得到最大的。 int MaxSum(int*a ,int *besti,int &bestj){ int sum=0,T; for(int i=1;i<=n;i++) for(int j=i;i<=n;j++){ T=0; for(int k=i;k<=j;k++...
动态规划---最大子段和，最大子矩阵和，最大m子段和
热门推荐
Unique-You的博客
12-21 1万+
1、最大子段和问题      问题定义：对于给定序列a1,a2,a3……an,寻找它的某个连续子段，使得其和最大。如( -2,11,-4,13,-5,-2 )最大子段是{ 11,-4,13 }其和为20。      (1)枚举法求解      枚举法思路如下：      以a[0]开始: {a[0]}, {a[0],a[1]},{a[0],a[1],a[2]}……{a[
leetCode: 求最大子段和，最大子段乘积，求除了其本身之外的其他数的乘积
徐赤赤的博客
04-17 1558
/** 最大子段和： */ int maxSubArray(vector& nums) { vectorres(nums.size(),INT_MIN); res[0] = nums[0]; for(int i=1;i<res.size();i++){ res[i] =max(res[i-1]+nums[i],nums[i]); } int
python 最大子段和
最新发布
09-01
Python中求解最大子段和可以使用动态规划的方法。 动态规划的思想是将原问题拆解成若干个子问题，通过求解子问题的最优解来得到原问题的最优解。对于最大子段和问题，可以定义一个状态数组dp，其中dp[i]表示以第i个...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值