LeetCode算法题目之53.最大子序和

LeetCode算法题目之53.最大子序和

题目描述：

给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。

涉及数据结构和算法：

动态规划

贪心

示例 1：

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

示例 2：

输入：nums = [1]
输出：1

示例 3：

输入：nums = [0]
输出：0

示例 4：

输入：nums = [-1]
输出：-1

示例 5：

输入：nums = [-100000]
输出：-100000

提示：

1 <= nums.length <= 3 * 104
-105 <= nums[i] <= 105

解答：

一：动态规划方式

    public static void main(String[] args) {
        int[] ints = new int[]{-2,1,-3,4,-1,2,1,-5,4};
//        int[] ints = new int[]{0};
//        int[] ints = new int[]{1,2};

        System.out.println(maxSubArray1(ints));
//        System.out.println(maxSubArray2(ints));
    }

    //    动态规划方式，时间复杂度N，空间复杂度N
    public static int maxSubArray1(int[] nums) {
        // 定义数组长度
        int n = nums.length;
        // 定义目前的子序和subSum，以及子数组初始下标start
        // 若数组长度为1，直接返回数组值即可,即初始化子序和subSum为nums[0]
        int subSum = nums[0];
        int start = 0;

        // 否则有动态规划方程：subSum=max(subSum+num,num)
        // 按数组下标正序循环，
        //      1. 若subSum+num<num, 则取num为初始值start(跳出当前子数组循环)，进入下次循环    start= max((-2)+1,1)
        //          当前子序和为：上次子序和subSum与初始值start的较大者                       subSum= max(-2,1)=1 = 1(原-2)
        //      2. 否则,取当前子序和subSum+num作为初始值start，继续当前循环;    start= max(0+(-2),-2) = -2
        //          当前子序和为：上次子序和subSum与初始值start的较大者();      subSum= max(-2,-2) = -2(原1)

        for(int i=0; i<n; i++){
            int num = nums[i];
            start = Math.max(start+num,num);// 更新子数组初始值 //start=max(0+(-2),-2)=-2;start=max(-2+1,1)=1;start=max(1+(-3),-3)=-2
            subSum=Math.max(subSum,start);//更新当前子序和 //subSum=max(-2,-2)=-2;subSum=max(-2,1)=1;subSum=max(1,-2)=1

        }
        return subSum;
    }

二：贪心方式

    public static void main(String[] args) {
        int[] ints = new int[]{-2,1,-3,4,-1,2,1,-5,4};
//        int[] ints = new int[]{0};
//        int[] ints = new int[]{1,2};

//        System.out.println(maxSubArray1(ints));
        System.out.println(maxSubArray2(ints));
    }

//    贪心方式，时间复杂度？，空间复杂度？
    public static int maxSubArray2(int[] nums) {
        // 定义数组长度
        int n = nums.length;
        // 定义目前的子序和subSum
        int subSum = nums[0];
        // 定义数组下标正序数组值累加和sum
        int sum = 0;

        for(int i=0; i<n; i++){
            int num = nums[i];
            sum = Math.max(sum,0); //若当前累加值<=0，取0作为新的累加值                                      0;0;1;0;4;3;5;6;1
            sum += num; // 当前循环正式更新累加值                                                           -2;1;-2;4;3;5;6;1;5
            subSum = Math.max(subSum,sum); // 更新目前的子序和，若当前累加值>目前的子序和，更新子序和为当前累加值 -2;1;1;4;4;5;6;6;6
        }
        return subSum;
    }