LeetCode-53 最大子序和（动态规划、贪心）

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

示例

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

这里我主要采用了暴力法、动态规划、以及贪心算法。其中动态规划与贪心算法的时间复杂度都是O(n),并且算法的思路非常相似，而暴力破解的复杂度相对较高，为O(n2)。当然，LeetCode题解中还有关于分治法的相关题解，以为时间复杂度不如动态规划与贪心算法，因此这里不再提及，如果想要了解分治法的朋友可以去LeetCode题解中查看详细思路。

方法一：暴力破解-----O(n2)

		private int maxSubArray(int[] nums) {
	        //初始最大值
	        int max=nums[0];
	        //第一次遍历数组
	        for (int i = 0; i <nums.length ; i++) {
	            //每次一遍历，sum初始都为0
	            int sum=0;
	            //遍历数组，求和
	            for (int j = i; j <nums.length ; j++) {
	                //求和
	                sum+=nums[j];
	                if (sum>max)
	                {
	                    max=sum;
	                }
	            }
	        }
	        return max;
    }

暴力破解的时间复杂度最大，当然思路也最简单。
首先使两边遍历数组，第一遍的目的是使每一个数组元素都能够当子序列的头部元素，第二遍的目的是为了能够获得全部的子序列组合。
当获得了全部的子序列组合，便可以将他们的和得出，从而得出最大的子序列和。

方法二：贪心法-----O(n)

private int maxSubArray(int[] nums)
    {
        //当前连续和
        int currentSum;
        //之前连续
        int preSum=0 ;
        //最大连续和
        int maxSum=nums[0];
        for (int num : nums) {
            if (preSum <= 0) {
                //若之前和小于0，则丢弃之前和，并将当前所指元素赋予currentSum
                currentSum = num;
            } else {
                //若之前和大于0，则将之前和与当前相加
                currentSum = preSum + num;
            }
            if (currentSum > maxSum) {
                maxSum = currentSum;
            }
            preSum = currentSum;
        }
        return maxSum;
    }

贪心法的主要思想是：遍历数组，并计算序列和，若当前选择元素之前的序列和小于0，则丢弃当前元素之前的数列。
因为如果之前的序列和（preSum）小于0，则之前的序列和（preSum）对当前所选元素并无增益。换句话说，当之前序列和小于0的序列与当前元素组成新的序列，那么新的序列和（currentSum）只会小于当前元素的值，那么这次相加就无意义了。因此要丢弃之前的序列和，将当前所选元素定义为新的序列和的第一个元素

方法三：动态规划-----O(n)

private int maxSubArray(int[] nums){
            //之前有效的序列和
            int preNum=nums[0];
            //最大序列和
            int maxNum=nums[0];
            for (int i = 1; i <nums.length ; i++) {
                if (preNum>0)
                {
                    //当preNum大于0，则preNum变为preNum+nums[i](加上当前元素)
                    preNum+=nums[i];
                }
                else
                {
                    //当preNumx小于0，则抛弃之前序列和，使preNum为当前元素
                    preNum = nums[i];
                }
                //获取最大序列和
                maxNum = Math.max(maxNum,preNum);
            }
            return maxNum;
        }

在这道题中，动态规划法与贪心法实质上是相同的，只是思考的思路有所不同。
动态规划的主要思想：若前一个元素大于0，则将其加到当前元素上。否则，保持当前元素值不变。
如同贪心法所说，如果之前的序列和小于0，则对当前元素并无增益。在动态规划中也是一样的，若之前的元素小于0，则对当前元素并无增益；如果大于0，则对当前元素有增益，加到当前元素上，实质上是将贪心中的序列和转化到元素值上。如果你能看懂上面的贪心法，那么动态规划你一定可以看懂。