首尾相连数组的最大子数组和

最新推荐文章于 2020-09-14 18:16:46 发布
最新推荐文章于 2020-09-14 18:16:46 发布
阅读量725 收藏
点赞数
分类专栏： 技术成长
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011031854/article/details/13019225
版权
这是一个关于数组处理的问题，目标是找到一个首尾相连的整数数组中，具有最大和的子数组。博客提供了两种解决方案：一种是首尾不相连的最大子数组和，另一种是首尾相连的最大和子数组，并给出了相应的C语言实现代码。
摘要由CSDN通过智能技术生成

题目

  1. 题目描述：  
  2. 给定一个由N个整数元素组成的数组arr，数组中有正数也有负数，这个数组不是一般的数组，其首尾是相连的。数组中一个或多个连续元素可以组成一个子数组，其中存在这样的子数组arr[i],…arr[n-1],arr[0],…,arr[j]，现在请你这个ACM_Lover用一个最高效的方法帮忙找出所有连续子数组和的最大值（如果数组中的元素全部为负数，则最大和为0，即一个也没有选）。  
  3. 输入：  
  4. 输入包含多个测试用例，每个测试用例共有两行，第一行是一个整数n（1=<n<=100000），表示数组的长度，第二行依次输入n个整数（整数绝对值不大于1000）。  
  5. 输出：  
  6. 对于每个测试用例，请输出子数组和的最大值。  
  7. 样例输入：  
  8. 6  
  9. 1 -2 3 5 -1 2  
  10. 5  
  11. 6 -1 5 4 -7  
  12. 样例输出：  
  13. 10  
  14. 14  
题目描述：
给定一个由N个整数元素组成的数组arr，数组中有正数也有负数，这个数组不是一般的数组，其首尾是相连的。数组中一个或多个连续元素可以组成一个子数组，其中存在这样的子数组arr[i],…arr[n-1],arr[0],…,arr[j]，现在请你这个ACM_Lover用一个最高效的方法帮忙找出所有连续子数组和的最大值（如果数组中的元素全部为负数，则最大和为0，即一个也没有选）。
输入：
输入包含多个测试用例，每个测试用例共有两行，第一行是一个整数n（1=<n<=100000），表示数组的长度，第二行依次输入n个整数（整数绝对值不大于1000）。
输出：
对于每个测试用例，请输出子数组和的最大值。
样例输入：
6
1 -2 3 5 -1 2
5
6 -1 5 4 -7
样例输出：
10
14

这里以 arr[6] = {1, -2, 3, 5, -1, 2}为例做介绍

首尾不相连最大子数组和

这是典型的动态规划题目，假设sum[i]为前i个数据的最大子数组和，则得到状态转移方程为：




有了状态转移方程，代码很容易实现（c语言）

[cpp] view plain copy print ?
  1. /** 
  2.  * 首尾不相连 
  3.  */  
  4. int maxSumNoConnect(int *arr, int n)  
  5. {  
  6.     int i, max, *sum;  
  7.     sum = (int *)malloc(sizeof(int) * n);  
  8.   
  9.     sum[0] = max = arr[0];  
  10.     for (i = 1; i < n; i ++) {  
  11.         if (sum[i - 1] > 0)  
  12.             sum[i] = arr[i] + sum[i - 1];  
  13.         else  
  14.             sum[i] = arr[i];  
  15.   
  16.         if (sum[i] > max) max = sum[i];  
  17.     }  
  18.   
  19.     free(sum);  
  20.     return max;  
  21. }  
/**
 * 首尾不相连
 */
int maxSumNoConnect(int *arr, int n)
{
	int i, max, *sum;
	sum = (int *)malloc(sizeof(int) * n);

	sum[0] = max = arr[0];
	for (i = 1; i < n; i ++) {
		if (sum[i - 1] > 0)
			sum[i] = arr[i] + sum[i - 1];
		else
			sum[i] = arr[i];

		if (sum[i] > max) max = sum[i];
	}

	free(sum);
	return max;
}

可以看到，这里我们用了O(n )的辅助数组sum，可以考虑直接简化辅助空间，代码如下：

[cpp] view plain copy print ?
  1. int maxSumNoConnectOne(int *arr, int n)  
  2. {  
  3.     int i, max, sum;  
  4.   
  5.     max = sum = arr[0] > 0 ? arr[0] : 0;  
  6.   
  7.     for (i = 1; i < n; i ++) {  
  8.         if ((arr[i] + sum) > 0) {  
  9.             sum += arr[i];  
  10.             max = max > sum ? max : sum;  
  11.         } else {  
  12.             sum = 0;  
  13.             max = max > arr[i] ? max : arr[i];  
  14.         }  
  15.     }  
  16.       
  17.     return max;  
  18. }  
int maxSumNoConnectOne(int *arr, int n)
{
	int i, max, sum;

	max = sum = arr[0] > 0 ? arr[0] : 0;

	for (i = 1; i < n; i ++) {
		if ((arr[i] + sum) > 0) {
			sum += arr[i];
			max = max > sum ? max : sum;
		} else {
			sum = 0;
			max = max > arr[i] ? max : arr[i];
		}
	}
	
	return max;
}



首尾相连最大和子数组

如果数组是首尾相邻的，可以分成两种情况来讨论：

（1） 如果最大和子数组没有跨过首元素，则可以用原问题的解法来求解

（2）如果最大和子数组跨过了首元素，则可以继续分两种情况讨论：

        1. 如果数组元素全部为正，则所有元素之和就是最大值
        2. 如果数组中有负数，则最大和子数组必然不包括某些元素，而不被包括的元素中必然有最小和子数组，这样我们就可以先查找最小和子数组的最后一个点，并以下一个点为起点，利用（1）的方法循环遍历一遍数组，就可以得到最大和子数组了

图示如下：




(ps:我靠，图片画歪了，算了，大家领会精神就好)

（1）可以用上面首尾不相连的做法求解

（2）的步骤如下

最小和子数组截止坐标

典型的动态规划思想，假设sum[i]为前i个数据的最小子数组和，则得到状态转移方程为：



实现代码（c语言）

[cpp] view plain copy print ?
  1. /** 
  2.  * 最小子数组和的截止坐标 
  3.  */  
  4. int indexInArrMinSum(int *arr, int n)  
  5. {  
  6.     int i, loc, min, *sum;  
  7.   
  8.     sum = (int *)malloc(sizeof(int) * n);  
  9.     min = sum[0] = arr[0];  
  10.     loc = 0;  
  11.   
  12.     for (i = 1; i < n; i ++) {  
  13.         if (sum[i - 1] > 0) {  
  14.             sum[i] = arr[i];  
  15.         } else {  
  16.             sum[i] = arr[i] + sum[i - 1];  
  17.         }  
  18.   
  19.         if (sum[i] < min) {  
  20.             loc = i;  
  21.             min = sum[i];  
  22.         }  
  23.     }  
  24.   
  25.     free(sum);  
  26.   
  27.     return loc;  
  28. }  
/**
 * 最小子数组和的截止坐标
 */
int indexInArrMinSum(int *arr, int n)
{
	int i, loc, min, *sum;

	sum = (int *)malloc(sizeof(int) * n);
	min = sum[0] = arr[0];
	loc = 0;

	for (i = 1; i < n; i ++) {
		if (sum[i - 1] > 0) {
			sum[i] = arr[i];
		} else {
			sum[i] = arr[i] + sum[i - 1];
		}

		if (sum[i] < min) {
			loc = i;
			min = sum[i];
		}
	}

	free(sum);

	return loc;
}

循环遍历

循环遍历只要从最小和子数组截止坐标下一个位置开始即可，无非遍历时需要注意取余而已

[cpp] view plain copy print ?
  1. /** 
  2.  * 首尾相连 
  3.  */  
  4. int maxSumConnect(int *arr, int n)  
  5. {  
  6.     int index, i, loc, cur, max, *sum;  
  7.   
  8.     sum = (int *)malloc(sizeof(int) * n);  
  9.   
  10.     index = indexInArrMinSum(arr, n);  
  11.       
  12.     max = sum[(index + 1) % n] = arr[(index + 1) % n];  
  13.   
  14.     for (i = 2; i < n; i ++) { // 不考虑最小子数组的截止坐标了   
  15.         loc = (index + i - 1) % n;  
  16.         cur = (index + i) % n;  
  17.         if (sum[loc] > 0) {  
  18.             sum[cur] = arr[cur] + sum[loc];  
  19.         } else {  
  20.             sum[cur] = arr[cur];  
  21.         }  
  22.           
  23.         if (sum[cur] > max)  
  24.             max = sum[cur];  
  25.     }  
  26.   
  27.     free(sum);  
  28.     return max;  
  29. }  
/**
 * 首尾相连
 */
int maxSumConnect(int *arr, int n)
{
	int index, i, loc, cur, max, *sum;

	sum = (int *)malloc(sizeof(int) * n);

	index = indexInArrMinSum(arr, n);
	
	max = sum[(index + 1) % n] = arr[(index + 1) % n];

	for (i = 2; i < n; i ++) { // 不考虑最小子数组的截止坐标了
		loc = (index + i - 1) % n;
		cur = (index + i) % n;
		if (sum[loc] > 0) {
			sum[cur] = arr[cur] + sum[loc];
		} else {
			sum[cur] = arr[cur];
		}
		
		if (sum[cur] > max)
			max = sum[cur];
	}

	free(sum);
	return max;
}

ac代码

[cpp] view plain copy print ?
  1. #include <stdio.h>   
  2. #include <stdlib.h>   
  3.    
  4. /** 
  5.  * 首尾不相连 
  6.  */  
  7. int maxSumNoConnect(int *arr, int n)  
  8. {  
  9.     int i, max, *sum;  
  10.     sum = (int *)malloc(sizeof(int) * n);  
  11.    
  12.     sum[0] = max = arr[0];  
  13.     for (i = 1; i < n; i ++) {  
  14.         if (sum[i - 1] > 0)  
  15.             sum[i] = arr[i] + sum[i - 1];  
  16.         else  
  17.             sum[i] = arr[i];  
  18.    
  19.         if (sum[i] > max) max = sum[i];  
  20.     }  
  21.    
  22.     free(sum);  
  23.     return max;  
  24. }  
  25.    
  26. /** 
  27.  * 最小子数组和的截止坐标 
  28.  */  
  29. int indexInArrMinSum(int *arr, int n)  
  30. {  
  31.     int i, loc, min, *sum;  
  32.    
  33.     sum = (int *)malloc(sizeof(int) * n);  
  34.     min = sum[0] = arr[0];  
  35.     loc = 0;  
  36.    
  37.     for (i = 1; i < n; i ++) {  
  38.         if (sum[i - 1] > 0) {  
  39.             sum[i] = arr[i];  
  40.         } else {  
  41.             sum[i] = arr[i] + sum[i - 1];  
  42.         }  
  43.    
  44.         if (sum[i] < min) {  
  45.             loc = i;  
  46.             min = sum[i];  
  47.         }  
  48.     }  
  49.    
  50.     free(sum);  
  51.    
  52.     return loc;  
  53. }  
  54.    
  55. /** 
  56.  * 首尾相连 
  57.  */  
  58. int maxSumConnect(int *arr, int n)  
  59. {  
  60.     int index, i, loc, cur, max, *sum;  
  61.    
  62.     sum = (int *)malloc(sizeof(int) * n);  
  63.    
  64.     index = indexInArrMinSum(arr, n);  
  65.        
  66.     max = sum[(index + 1) % n] = arr[(index + 1) % n];  
  67.    
  68.     for (i = 2; i < n; i ++) { // 不考虑最小子数组的截止坐标了   
  69.         loc = (index + i - 1) % n;  
  70.         cur = (index + i) % n;  
  71.         if (sum[loc] > 0) {  
  72.             sum[cur] = arr[cur] + sum[loc];  
  73.         } else {  
  74.             sum[cur] = arr[cur];  
  75.         }  
  76.            
  77.         if (sum[cur] > max)  
  78.             max = sum[cur];  
  79.     }  
  80.    
  81.     free(sum);  
  82.     return max;  
  83. }  
  84.    
  85. int main(void)  
  86. {  
  87.     int i, n, flag, conn_n, conn_y, *arr;  
  88.    
  89.     while (scanf("%d", &n) != EOF) {  
  90.         arr = (int *)malloc(sizeof(int) * n);  
  91.         for (i = 0, flag = 0; i < n; i ++) {  
  92.             scanf("%d", arr + i);  
  93.             if (*(arr + i) <= 0)  
  94.                 flag ++;  
  95.         }  
  96.    
  97.         // 均为负数返回0   
  98.         if (flag == n) {  
  99.             printf("0\n");  
  100.             continue;  
  101.         }  
  102.    
  103.         conn_n = maxSumNoConnect(arr, n);  
  104.         conn_y = maxSumConnect(arr, n);  
  105.         if (conn_n < conn_y)  
  106.             printf("%d\n", conn_y);  
  107.         else  
  108.             printf("%d\n", conn_n);  
  109.         free(arr);  
  110.     }  
  111.    
  112.     return 0;  
  113. }  
  114.    
  115.    
  116. /************************************************************** 
  117.     Problem: 1527 
  118.     User: wangzhengyi 
  119.     Language: C 
  120.     Result: Accepted 
  121.     Time:80 ms 
  122.     Memory:2084 kb 
  123. ****************************************************************/  
lakers_bing
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
最大连续子序列算法（数组的连续子数组最大和（首尾不相连））
左_右
08-30 2488
相关描述： 连续子序列最大和，其实就是求一个序列中连续的子序列中元素和最大的那个。 比如例如给定序列： { -5，-2, 11, -4, 13, -5, -8 } 其最大连续子序列为{ 11, -4, 13 }，最大和为20。 方法一：暴力 O（n^3） 算法描述： 暴力搞来就是枚举子序列的起点和终点，然后计算这一段的和，再通过不断地更新最大值即可。但是效率太低了。 代
最大连续子数组之和
皮皮狗
09-09 540
给一个数组，返回它的最大连续子序列的和。例如:{6,-3,-2,7,-15,1,2,2},连续子向量的最大和为8(从第0个开始,到第3个为止)。
数组的连续子数组最大和（首尾相连）
weixin_34061042的博客
10-20 543
题目： 求一个循环数组的连续子数组的最大和。 解法： 《编程之美》上给出一种方法： 1）求[0, n-1]的最大和； 2）如果跨过了n-1，则计算以n-1为尾部的最大子数组[i, n-1]，以0为开始的最大子数组[0 , j]； 如果i<=j，则M = a[0]+...+a[n-1]; 否则，M= a[0]+...+a[j] + a[i]+...a[n-1]. 该方法...
【字符串排序】n个数连接得到最小或最大的多位整数
weixin_33946605的博客
03-29 370
题目 描述：设有n个正整数，将它们依次连成在一排，组成一个多位数，现在要求可能组成的多位数中最大的多位数是什么？ 例如：n=3时，3个整数13，312，343连成的最大多位数为：343-312-13。 例如：n=4时，4个证书7，13，4，246连成的最大多位数为：7-4-246-13。 输入：n个整数，EOF结尾。 输出：最大的多位数。 算法分析 　　此题很容易想到使用贪心法。 ...
单调队列-首尾相连数组的最大子数组和
thewebcode
07-26 239
题目描述： 给定一个由N个整数元素组成的数组arr，数组中有正数也有负数，这个数组不是一般的数组，其首尾是相连的。数组中一个或多个连续元素可以组成一个子数组，其中存在这样的子数组arr[i],…arr[n-1],arr[0],…,arr[j]，现在请你这个ACM_Lover用一个最高效的方法帮忙找出所有连续子数组和的最大值（如果数组中的元素全部为负数，则最大和为0，即一个也没有选）。...
首尾相连的一位数组最大子数组和
weixin_34161032的博客
03-30 133
题目：在原有的一位数组上进行扩展，求首尾相连的最大子数组的和： 要求： 输入一个一维整形数组，数组里有正数也有负数。 数组中连续的一个或多个整数组成一个子数组，每个子数组都有一个和。 求所有子数组的和的最大值。 结对编程要求： 两人结对完成编程任务。 一人主要负责程序分析，代码编程。 一人负责代码复审和代码...
求数组的连续子数组之和的最大值（一维二维）
承续缘的信仰
07-22 5177
求数组的连续子数组之和的最大值 输入一个N个元素的整型数组，数组里有正数也有负数。数组中连续的一个或多个整数组成一个子数组，每个子数组都有一个和。求所有子数组的和的最大值。 例如输入的数组为-9  -3  -2  2  -1  2  5  -7  1  5，和最大的子数组为2  -1  2  5。因此输出为该子数组的和8。 可是如果都是负数的话，要返回0？还是返回最小的负数？，这个数时
什么是环形数组以及学习环形数组的意义是什么
最新发布
05-13
1. **首尾相连**：数组的逻辑结构使其首尾相连，形成闭环。 2. **固定大小**：环形数组的大小通常是固定的，一旦定义后就不再改变。 3. **高效操作**：对于插入和删除操作，时间复杂度为 O(1)。 4. **内存优化**：...
java数组-基于java实现的环形缓冲数组.zip
03-14
环形缓冲数组的基本概念是数组的首尾相连，形成一个闭合的环。当数组填满时，新的元素会覆盖旧的元素，而不是扩展数组大小。这使得环形缓冲数组在处理流式数据或者需要限制缓冲区大小的应用场景下特别有用，如网络...
环形数组介绍要点和难点具体应用实例和代码解析
05-13
由于其首尾相连的特性，插入和删除操作往往比普通数组更加高效，尤其是在实现循环队列时。当数组满时，环形队列的入队操作会覆盖最前面的元素，而不会像普通队列那样需要重新分配内存。同样，出队操作也会从队头开始...
连续子数组的最大和（含返回最大子数组起始位置、全负数组、数组跨界问题）
godric_star的博客
08-24 1003
连续子数组的最大和（含返回最大子数组起始位置、全负数组、数组跨界问题）题目：输入一个整型数组，数组里有正数也有负数。数组中一个或连续的多个整数组成一个子数组。求所有子数组的和的最大值。要求时间复杂度为O(n)。 Markdown和扩展Markdown简洁的语法 代码块高亮 图片链接和图片上传 LaTex数学公式 UML序列图和流程图 离线写博客 导入导出Markdown文件 丰富的快捷键 快捷键 加
NYOJ-983-首尾相连数组的最大子数组和
jsmok_xingkong的博客
04-14 313
时间限制：1000 ms  |  内存限制：65535 KB 难度：4 描述 给定一个由N个整数元素组成的数组arr，数组中有正数也有负数，这个数组不是一般的数组，其首尾是相连的。数组中一个或多个连续元素可以组成一个子数组，其中存在这样的子数组arr[i],…arr[n-1],arr[0],…,arr[j]，现在请你这个ACM_Lo
数组2——数组首尾相接，求最大子数组
言凡的博客
03-26 502
结对开发，我和秦冰超２０１３２９００，博客地址　http://www.cnblogs.com/qinxian0/ 设计思路： 　　输入数组 １ －4 －2 7  　　a[0]=sz[0];１ 　　a[1]=max(a[0]+sz[1],sz[1]);－３ 　　a[2]=max(a[1]+sz[2],sz[2]);－２ 　　a[3]=max(a[2]+sz[3],sz[3]);７ 　　max(a[...
剑指Offer对答如流系列 - 连续子数组的最大和
明月沉江春雾晓
01-30 2040
文章目录面试题42：连续子数组的最大和一、题目描述二、问题分析三、问题解答 面试题42：连续子数组的最大和 一、题目描述 输入一个整型数组，数组里有正数也有负数。数组中一个或连续的多个整/数组成一个子数组。求所有子数组的和的最大值。要求时间复杂度为O(n)。 二、问题分析 输入数组{1、-2、10、-4、7、2、-5} 很容易看出从第一个数字开始累加，若走到某一个数字时，前面的累加和为负数，说明...
首尾相连的循环数组求其子数组最大值
weixin_30653097的博客
03-31 200
结对成员 　　曹坤 翟凯 题目 　　返回一个整数数组中最大子数组的和。 要求： 　　输入一个整形数组，数组里有正数也有负数。 　　数组中连续的一个或多个整数组成一个子数组，每个子数组都有一个和。 　　如果数组A[0]……A[j-1]首尾相邻，允许A[i-1]，……A[n-1]，A[0]……A[j-1]之和最大。 　　同时返回最大子数组的位置。 思路 　　经过讨论，只需将...
求首尾相连的数组最大子数组之和
weixin_41935140的博客
09-14 249
负数对于子数组求和起反作用，所以以第一个出现的负数作为切入点切断数组； import copy l = [20, -10, 3, 5, -7, 10, 40] # l = [20, 10, 3, 5, 7, 10, 40] def getMax(l): nl = copy.copy(l) for k, i in enumerate(l): if i <0 and i: nl = nl[k:] nl.extend(l..
包含10个元素的一维整型数组a，元素值从键盘输入；找出数组a中连续3个数据元素的和最大的，并输出这3个数据元素。（注意该一维数组首尾相连）
12-01
以下是C语言的代码实现，用于找出数组a中连续3个数据元素的和最大的，并输出这3个数据元素： ```c #include int main() { int a[10], i, max_sum = -2147483648, max_index = 0; for (i = 0; i ; i++) { scanf...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值