LeetCode-53 最大子序和

最新推荐文章于 2021-09-23 14:41:39 发布

原创最新推荐文章于 2021-09-23 14:41:39 发布 · 347 阅读

0 ·

CC 4.0 BY-SA版权

LeetCode 没日没夜刷专栏收录该内容

9 篇文章

订阅专栏

博客围绕数组最大子序列问题展开，介绍了从头遍历的常规思路，将数组元素分为A、B模块，根据B模块值决定是否加入A模块并记录最大值。还提及进阶的分治解法，把原问题分割成子问题，分别求解后组合得到原问题的解，同时阐述了分治的分割与组合要点。

题目描述：

思路想法：

我们可以从头开始遍历，仍然是数组模块的思想，把遍历指向的当前元素和已经形成的子数组分成两个模块A,B（注意：B模块初始为空）；我们只需要考虑：什么时候舍去B模块的这个大尾巴；在加入A模块时，新的B模块是否大于0；大于0就加入，否则不该加入A。并且B模块在此发生断裂，这时我们需要记住B模块存在过的最大值，然后，继续往后遍历。

最后我们得到了很多个 B 模块的最大值，取它们中间的最大的哪个作为答案。

对于上面的示例：按照这个原则；A=-2；B=[]; A+B = -2 不大于 0 ；舍去，但仍保留-2作为第一个B模块的最大值，继续；下一个B模块:B=[]; A = -3; 不大于0；舍去，但仍保留第二个B模块的最大值，继续；下一个 A=4;B=[];A+B=4 大于0；A=-1；A+B=3 大于0；A=2；A+B = 5 大于0；A=1 ;A+B = 6，A=-5；A+B = 1 大于0 A=4；A+B=5 完；在没有断裂的情况下，我们已经在加入新元素的时候，变更了B模块的最大值。

进阶思路：

是的，还有更变态的解法---分治

将原问题分成左右两个子问题，分别求 left 最大子序列 right 最大子序列和中间的最大子序列，最后返回 Max(left , mid, right);

Java 代码：

正常解法：

class Solution {
    public int maxSubArray(int[] nums) {
        
        int len=nums.length;
        // int[] tempMemary = new int[len];   //为每一个旧组保留最大值
        // tempMemary[0]=nums[0]; // 初始值设定，易错点
        int[] tempMemary = nums;
        int tempSum = 0;                   //临时组和
        int local = 0;
        
        for (int i=0;i<len;i++){
           
            tempSum += nums[i]; // 首个组的首个临时组和
            tempMemary[local] = Math.max(tempSum,tempMemary[local]);
            
            if (tempSum<=0){ // 表明旧组断裂
                local++;
                tempSum = 0;
            }
        }
        
        int ans = tempMemary[0];
        for (int k=1;k<len;k++){
            ans = Math.max(ans,tempMemary[k]);
        }
        return ans;
        
    }
    
}

分治算法：

class Solution {
    public int maxSubArray(int[] nums) {
        
        if (nums.length== 2){
            return Math.max(Math.max(nums[0],nums[1]),nums[0]+nums[1]);
        }
        
        if (nums.length==1){return nums[0];}
        // 以下代码处理nums长度大于2的情况
        return maxLeftMidRight(nums,0,nums.length-1);
    }
    
    
    
    // 递归分治解决问题

    private int maxLeftMidRight(int[] nums,int left,int right){
        if (left==right){
            return nums[left];
        }

        if (right-left < 2){
            return Math.max(Math.max(nums[left],nums[right]),nums[left]+nums[right]);
        }

        int mid = left+(right-left)/2; // 下中位数




        int maxLeft = maxLeftMidRight(nums,left,mid-1);
        int maxRight = maxLeftMidRight(nums,mid+1,right);
        int maxMid = maxMidHelper(nums,mid,left,right);
        return Math.max(Math.max(maxLeft,maxRight),maxMid);

    }

   // 此函数帮助找到以中间数为基准找到max子序列

    private int maxMidHelper(int[] nums,int mid,int left,int right ){

        int countSum = nums[mid];
        // mid 向右找
        int memery_1 = nums[mid];

        for (int i=mid+1;i<=right;i++){
            countSum += nums[i];
            memery_1 = Math.max(countSum,memery_1);

        }


        int countSum_1=nums[mid];
        // 向左找
        int memery_2 = nums[mid];
        for (int i=mid-1;i>=left;i--){
            countSum_1 += nums[i];
            memery_2 = Math.max(countSum_1,memery_2);
        }

        return Math.max(memery_1+memery_2-nums[mid],Math.max(memery_1,memery_2));

    }
    
    
    
}