力扣剑指 Offer 42. 连续子数组的最大和的多种解法

题目描述：

输入一个整型数组，数组中的一个或连续多个整数组成一个子数组。求所有子数组的和的最大值。

要求时间复杂度为O(n)。

示例1:

输入: nums = [-2,1,-3,4,-1,2,1,-5,4]
输出: 6
解释: 连续子数组 [4,-1,2,1] 的和最大，为 6。

提示：

• 1 <= arr.length <= 10^5

方法一（不符合题意）：暴力破解初始版  时间复杂度为

• 首先想到的时间复杂度为的暴力解法，利用for循环将数组nums的所有子序列和求解出来，然后将最大的子数组和保留下来，返回max即可

•     public int maxSubArray(int[] nums) {
          int max = Integer.MIN_VALUE;
          for (int i = 0; i < nums.length; i++) {
              for (int j = i; j < nums.length; j++) {
                 //子数组更换，sum清零
                  int sum = 0;
                  for (int k = i; k < j; k++) {
                      //计算nums[i]到nums[j]的和
                      sum += nums[k];
                      //如果sum的值比max大，将max的值进行更新
                      if (sum > max) {
                          max = sum;
                      }
                  }
              }
          }
          return max;
      }

  方法二（不符合题意）：暴力破解升级版 时间复杂度为

• 方法一中的第三个循环，可以省略，得到一个时间复杂度为的解决方案

    public int maxSubArray3(int[] nums) {
        int max = Integer.MIN_VALUE;
        for (int i = 0; i < nums.length; i++) {
            //i每一次更新之后，sum清零
            int sum = 0;
            for (int j = i; j < nums.length; j++) {
                //计算从nums[i]到nums[j]的和
                sum += nums[j]; 
                //j每更新一次，sum和max都会进行比较一次，取最大值
                if (sum > max) {
                    max = sum;
                }
            }
        }
        return max;
    }

方法三（较难）：分而治之  时间复杂度

解决问题的思想来自浙大数据结构课程中陈越老师的讲解

实现方法借鉴自：力扣官方

分治的思想就是将nums数组一直对半划分，直到每一组数就只有一个数字，分别找出最小一组的数据最大值，然后将这些数据逐渐合并起来，寻找最大值，在这里一定要注意数组必须要连续，一直说有一点抽象，下面：

举个例子：假设数组nums = [4,-3,5,-2,-1,2,6,-2]，

第一次进行划分 nums1 = [4,-3,5,2]   nums2 = [-1,2,6,-2]

第二次进行划分 nums1 = [4,-3] nums2 = [5,-2] nums3 = [-1,2] nums4 = [6,2]

第三次进行划分 nums1 = [4] nums2 = [-3] nums3 = [5] nums4 = [-2]

                          nums5 = [-1] nums6 = [2] nums7 = [6] nums8 = [-2]

第一次进行合并 在 4 与 -3 中最大的是 4     在 5 与 -2 中最大的是 5 

                           在 -1 与 2 中最大的是 2    在 6 与 -2 中最大的是 6

第二次进行合并

在 4 3 5 -2 中的最大子数组和为 4+（-3）+ 5  =  6

为什么不是9，因为要连续的子序列

在 -1 2 6 -2 的最大子数组和为 2 + 6 = 8

第三次进行合并，在数组nums中，最大子数组和为 4 + （-3） + 5 + (-2) + (-1) + 2 + 6 = 11

 说了这么多怎么实现呢？

以下是力扣官方的解释：

对于官方解析，我讲解一下自己有疑惑的部分： 

对于【l,r】的 lSum 的结果等于【左子区间】的lSum，即当【右子区间】全部为负数的情况，而【l,r】的 lSum 的结果等于【左子区间】的 iSum  加上【右子区间】的 lSum 可以参考第二次进行合并 在 4 3 5 -2 中的最大子数组和为 4+（-3）+ 5  =  6

对于【l,r】的 rSum 的结果同理

最后计算【l,r】的mSum的结果，可以参考在第三次合并时，在数组nums中，最大子数组和为 4 + （-3） + 5 + (-2) + (-1) + 2 + 6 = 11

官方代码展示如下：

class Solution {
    public class Status {
        public int lSum, rSum, mSum, iSum;

        public Status(int lSum, int rSum, int mSum, int iSum) {
            this.lSum = lSum; //lSum 表示 [l,r] 内以 l 为左端点的最大子段和
            this.rSum = rSum; //rSum 表示 [l,r] 内以 r 为右端点的最大子段和
            this.mSum = mSum; //mSum 表示 [l,r] 内的最大子段和
            this.iSum = iSum; //iSum 表示 [l,r] 的区间和
        }
    }

    public int maxSubArray(int[] nums) {
        return getInfo(nums, 0, nums.length - 1).mSum;
    }

    public Status getInfo(int[] a, int l, int r) {
        if (l == r) {
            return new Status(a[l], a[l], a[l], a[l]);
        }
        int m = (l + r) >> 1;
        Status lSub = getInfo(a, l, m);
        Status rSub = getInfo(a, m + 1, r);
        return pushUp(lSub, rSub);
    }

    public Status pushUp(Status l, Status r) {
        int iSum = l.iSum + r.iSum;
        int lSum = Math.max(l.lSum, l.iSum + r.lSum);
        int rSum = Math.max(r.rSum, r.iSum + l.rSum);
        int mSum = Math.max(Math.max(l.mSum, r.mSum), l.rSum + r.lSum);
        return new Status(lSum, rSum, mSum, iSum);
    }
}

//作者：力扣官方题解
//链接：https://leetcode.cn/problems/lian-xu-zi-shu-zu-de-zui-da-he-lcof/solutions/876881/lian-xu-zi-shu-zu-de-zui-da-he-by-leetco-tiui/

方法四(推荐)：动态规划 时间复杂度

直接上代码：这是我刚开始写的一版，把nums.length为1的情况以及如果nums数组中的所有元素全部都是负数的情况单独进行讨论

    public int maxSubArray(int[] nums) {
        int thisNum = 0;
        int maxNum = 0;
        int max = Integer.MIN_VALUE;
        if (nums.length == 1) {
            return nums[0];
        }
        for (int i = 0; i < nums.length; i++) {
            if (nums[i] > max) {
                max = nums[i];
            }
            if (max < 0) {
                maxNum = max;
            }
        }
        for (int i = 0; i < nums.length; i++) {
            thisNum += nums[i];
            if (thisNum > maxNum) {
                maxNum = thisNum;
            } else if (thisNum < 0) {
                thisNum = 0;
            }
        }
        return maxNum;
    }

这个是思考后又进行优化的版本

    public int maxSubArray(int[] nums) {
        int maxSum = nums[0];
        int sum = nums[0];
        for (int i = 1; i < nums.length; i++) {
            sum+=nums[i];//前缀
            sum=Math.max(sum,nums[i]);
            maxSum=Math.max(sum,maxSum);
        }
        return maxSum;
    }