Maximum Subarray

Maximum Subarray

Given an integer array nums, find the contiguous subarray (containing at least one number) which has the largest sum and return its sum.
Input: [-2,1,-3,4,-1,2,1,-5,4],
Output: 6
Explanation: [4,-1,2,1] has the largest sum = 6.

分治法

三个阶段

划分：整个问题划分为多个子问题
求解：递归求解各个子问题
合并：合并子问题的解，形成原始问题的解

答案会出现的地方
1、数组的左半部分最大序列和
2、数组的右半部分最大序列和
3、横跨左右部分的最大序列和

/**
  author:monkey
  time:2020-2-19
*/
 public int maxSubArray(int[] nums) {
        return MaxSum(nums,0,(nums.length-1));
    }
    public int MaxSum(int nums[],int left,int right){
        if(left == right){
            return nums[left];
        }//递归基准结束条件
        int mid;
        mid = (right + left)/2;//中间点

        int MaxLeftSum;
        MaxLeftSum = MaxSum(nums,left,mid);//递归,左半边部分的最大子序列和

        int MaxRightSum;
        MaxRightSum = MaxSum(nums,mid+1,right);//递归,右半边部分的最大子序列和
        /*
           从中间开始往左边循环加,找出中间到左边最大的序列和
        */
        int MaxmidLeftSum = 0;//从中间往左边加
        int midLeftBorder = nums[mid];//左边假定子序列为单个索引mid最大
        for(int i = mid;i >= left;i--){
            MaxmidLeftSum += nums[i];
            if(MaxmidLeftSum > midLeftBorder){
                midLeftBorder = MaxmidLeftSum;
            }
        }
        /*
           从中间开始往右边循环加,找出中间到右边最大的序列和
        */
        int MaxmidRightSum = 0;
        int midRightBorder = nums[mid+1];//右边假定子序列为单个索引mid+1最大
        for(int i = mid+1;i <= right;i++){
            MaxmidRightSum += nums[i];
            if(MaxmidRightSum > midRightBorder){
                midRightBorder = MaxmidRightSum;
            }
        }
        /*
          最后比较左边部分最大子序列、右边部分最大子序列、跨左右部分的最大子序列
        */
        return Integer.max(Integer.max(midLeftBorder+midRightBorder,MaxLeftSum),MaxRightSum);
    }

测试

import java.util.Scanner;

public class Test4 {
    public static int maxSubArray(int[] nums) {
        return MaxSum(nums,0,(nums.length-1));
    }
    public static int MaxSum(int nums[],int left,int right){
        if(left == right){
            return nums[left];
        }//递归基准结束条件
        int mid;
        mid = (right + left)/2;//中间点

        int MaxLeftSum;
        MaxLeftSum = MaxSum(nums,left,mid);//递归,左半边部分的最大子序列和

        int MaxRightSum;
        MaxRightSum = MaxSum(nums,mid+1,right);//递归,右半边部分的最大子序列和
        /*
           从中间开始往左边循环加,找出中间到左边最大的序列和
        */
        int MaxmidLeftSum = 0;//从中间往左边加
        int midLeftBorder = nums[mid];//左边假定子序列为单个索引mid最大
        for(int i = mid;i >= left;i--){
            MaxmidLeftSum += nums[i];
            if(MaxmidLeftSum > midLeftBorder){
                midLeftBorder = MaxmidLeftSum;
            }
        }
        /*
           从中间开始往右边循环加,找出中间到右边最大的序列和
        */
        int MaxmidRightSum = 0;
        int midRightBorder = nums[mid+1];//右边假定子序列为单个索引mid+1最大
        for(int i = mid+1;i <= right;i++){
            MaxmidRightSum += nums[i];
            if(MaxmidRightSum > midRightBorder){
                midRightBorder = MaxmidRightSum;
            }
        }
        /*
          最后比较左边部分最大子序列、右边部分最大子序列、跨左右部分的最大子序列
        */
        return Integer.max(Integer.max(midLeftBorder+midRightBorder,MaxLeftSum),MaxRightSum);
    }
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while(true){
            System.out.print("请输入你的序列个数:");
            int cnt = sc.nextInt();
            if(cnt == 0){
                break;
            }
            int num[] = new int[cnt];
            System.out.print("请输入一段序列：");
            for(int i = 0;i < cnt ;i++){
                num[i] = sc.nextInt();
            }
            int res = maxSubArray(num);
            System.out.println("该序列的最大子序列和为："+res);
        }
    }
}

有一说一，明明分治法复杂…

---

动态规划

标准动态规划方程.java
时间复杂度O(n)，空间复杂度O(n)

public static int maxSubArray(int[] nums){
     if (nums == null || nums.length == 0) return 0;
     int res = 0;
     //1.状态定义,dp[i]表示包含第i项的前i项和最大值
     int[] dp = new int[nums.length];
     //2.状态初始化,数组中的第一个元素的最大和就是其本身
     dp[0] = nums[0];
     res = nums[0];
     //3.状态转移方程 dp[i] = max(dp[i-1],0) + nums[i]
     for (int i = 1;i < nums.length;i++){
          dp[i] = Math.max(dp[i-1],0)+nums[i];
          res = Math.max(res,dp[i]);
      }
     return res;
  }

优化测试.java
时间复杂度O(n)，空间复杂度O(1)

package monkey.study.test;

import java.util.Scanner;

public class Test1 {

    /* 动态算法 - - 最大子序和*/
    public static int maxSubArray(int[] nums){
         if (nums == null | nums.length ==  0) return 0;
         int res = 0;
         int currSum = nums[0]; //之前和
         res = nums[0]; //当前和
         for (int i = 1; i < nums.length; i++){
             currSum = Math.max(currSum,0) + nums[i]; //每一次比较,如果有负数加上去肯定更小,那就不加
             res = Math.max(res,currSum);//这里更新最大子序列和
         }
        return res;
    }
    
    /*测试*/
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("请输入数组长度：");
        int len = sc.nextInt();
        System.out.print("请输入数组：");
        int[] nums = new int[len];
       for (int i = 0;i < len;i++){
           nums[i] = sc.nextInt();
       }
      int res = maxSubArray(nums);
        System.out.println("最长子序段和为："+res);
    }
}

通过遍历累加这个数组元素，每一次遍历更新最大字段和res，如果当前累加数为负数，直接舍弃，重置为0，然后接着遍历。（为什么要舍弃置为0？如果当前和currSum是负数，那么当下一个数组元素是正数时，比负数大的多，才舍弃置位0加上下一个正数元素；当下一个数组元素是负数时，currSum加上一个负数就更小了，那不如不加，直接置位0），或许突然想出，万一全是负数，后面的负数小于前年的负数呢？(不是已经置为0了吗，置为0每一次都在更新，res的每一次更新都会与之前res与当前currSum进行对比)
以上算法，我们以[-2,1,-3,4,-1,2,1,-5,4]为例，将以上算法演示一遍。更新currSum=nums[0]=-2，res=nums[0]是个负数，遍历数组，从第二个数据开始(下标为1)，将当前和与0比较，如果之前和是负数，则不加上去，但加上当前下标数据，再更新当前和与结果和的结果
i=1，currSum=-2<0，更新currSum=0+nums[1]=1，更新res=1
i=2，currSum=1 > 0，更新currSum=1+nums[2]=-2，更新res=1
i=3，currSum=-2 <0，更新currSum=0+nums[3]=4，更新res=4
i=4，currSum=4 >0 ，更新currSum=4+nums[4]=3，更新res=4
i=5，currSum=3 >0，更新currSum=3+nums[5]=5，更新res=5
i=6，currSum=5>0，更新currSum=5+nums[6]=6，更新res=6
i=7，currSum=6 >0，更新currSum=6+nums[7]=1，更新res=6
i=8，currSum=1>0，更新currSum=1+nums[8]=5，更新res=6
最终结果是6
复杂度分析：
算法只有一个for循环，时间复杂度为O(n)，空间复杂度为O(1)

---

其他方法

传统思想解决：双重for循环，外层循环定位子序列开头，内层循环寻找子序列，循环比较此次的子序列和和上一个子序列的和（只多了一个数），复杂

//C传统思想暴力解决
//执行600ms(ps:这个执行时间有点恐怖!)
//消耗内存7.5MB
int maxSubArray(int* nums, int numsSize){
    int max;
    int i=0;
    int temp=nums[0];//假设第一个数字是最大,temp全局
    for(;i<numsSize;i++){
            int sum = 0;
        for(int j=i;j<numsSize;j++){
            sum += nums[j];
            if(sum >= temp){
               max =  sum;
               temp = sum;//将最大数赋值给temp,作比较
           }
        }
    }
    return max;
}

没有使用双重循环。
求最大序列和，如果碰到负数，那么这个序列和会减小
nums[i-1]不是数组i-1这一项，而存储的是在到第i-1项之前的最大子序列和，跟0比较是如果nums[i-1]为整数，可以和当前下标为i的数据相加构成最大子序列和，同时赋值给nums[i]，为下一次的循环的做好前一项的存储最大子序列和做准备。

//Java
//执行1ms
//消耗内存48.6MB
public int maxSubArray(int[] nums) {
        if(nums.length == 0){
           return 0;
        }
        int max = nums[0];//假设第一个最大
        for(int i=1;i<nums.length;i++){
           nums[i] += Math.max(nums[i-1],0);
           max = Math.max(max,nums[i]);
        }
        return max;
 }

//java另一种方法,妙啊
//执行用时1ms
//消耗内存42.2MB
 public int maxSubArray(int[] nums) {
        int max = nums[0];
        int sum = 0;
        //增强for循环
        for(int num : nums){
            if(sum>0){
                sum += num;
            }else{
                sum = num;
            }
            max = Math.max(max,sum);
        }
        return max;
    }