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

题目

题目描述： 给定一个由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

题目描述：
给定一个由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 plaincopyprint?

/** * 首尾不相连 */ 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; }

/**
* 首尾不相连
*/
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 plaincopyprint?

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; }

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 plaincopyprint?

/** * 最小子数组和的截止坐标 */ 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; }

/**
* 最小子数组和的截止坐标
*/
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 plaincopyprint?

/**
* 首尾相连
*/
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;
}

/**
* 首尾相连
*/
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 plaincopyprint?

#include <stdio.h>
#include <stdlib.h>

/** * 首尾不相连 */ 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; }
/** * 最小子数组和的截止坐标 */ 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; }

/**
* 首尾相连
*/
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;
}

int main(void)
{
int i, n, flag, conn_n, conn_y, *arr;

while (scanf("%d", &n) != EOF) {
arr = (int *)malloc(sizeof(int) * n);
for (i = 0, flag = 0; i < n; i ++) {
scanf("%d", arr + i);
if (*(arr + i) <= 0)
flag ++;
}

// 均为负数返回0
if (flag == n) {
printf("0\n");
continue;
}

conn_n = maxSumNoConnect(arr, n);
conn_y = maxSumConnect(arr, n);
if (conn_n < conn_y)
printf("%d\n", conn_y);
else
printf("%d\n", conn_n);
free(arr);
}

return 0;
}

/**************************************************************
Problem: 1527
User: wangzhengyi
Language: C
Result: Accepted
Time:80 ms
Memory:2084 kb
****************************************************************/