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

分类： C语言 算法 ACM 2013-07-22 09:27  122人阅读  评论(0)  收藏  举报

目录(?)[+]

前言

这是昨晚参加九度oj的7月份月赛碰到的题目，很有意思，今早查了一下，原来《编程之美》中已经讲过类似题目，看来我把《剑指offer》看完之后，下一本书就是《编程之美》了，今天6点起床想看会英语，可惜还是搞算法了

题目

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

 /**
  * 首尾不相连
  */
 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，可以考虑直接简化辅助空间，代码如下：

 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语言）

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

ac代码

 #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
 ****************************************************************/