连续子数组的最大和

<leecode 第53题>
输入一个整型数组，数组里有正数也有负数。数组中的一个或连续多个整数组成一个子数组。求所有子数组的和的最大值。
示例1:
输入: nums = [-2,1,-3,4,-1,2,1,-5,4]
输出: 6
解释: 连续子数组 [4,-1,2,1] 的和最大，为 6。

解答:

看到这种题目， 一目了然，我们第一想到的应该是穷举法， 复杂度为平方阶， 显然不是我们想要的，我们是否有时间复杂度为更小甚至为 O(n)的呢， 显然是有的

**

解法一: 分治算法

**

第一次 mid = (0 + 8) / 4
对 0 - 4 的序列进行递归求解
对5 - 8 的序列进行递归求解
，这样我们就算出来了右边序列和左边序列的最大连续子序列， 但是我们如果有一个连续的序列， 贯穿在左右之间怎么办， 所以我们也需要对中间的序列进行求解
从 index = 4开始
先往左边扩展 找到最大连续序列的和，
然后在往右边寻找， 一起便是中间的最大连续序列的和， 下面看代码

public int dfs(int[] nums, int start, int end) {

		// 递归终止条件
		if (start > end) {
			return 0;
		}
		// 只有一个数时， 这个数就是最大连续序列
		if (start == end) {
			return nums[start];
		}
		// 中间下标
		int mid = (start + end) / 2;
		// 这个变量记录往左右扩展时的中间变量
		int mid_sum = nums[mid];
		// 这个记录中间序列当前的最大值
		int max = mid_sum;
		// 往左边扩展
		for (int i = mid - 1; i >= start; i--) {
			// 这个变量一直累加
			mid_sum += nums[i];
			// 大于则更新
			if(max < mid_sum){
				max = mid_sum;
			}
		}
		// 往右边更新的时候 设置为当前左边序列的最大值
		mid_sum = max;
		for (int i = mid + 1; i <= end; i++) {
			mid_sum += nums[i];
			
			if(max < mid_sum){
				max = mid_sum;
			}		
		}
		// 递归求解
		int left = dfs(nums, start, mid);
		int right = dfs(nums, mid + 1, end);
		int sum = Math.max(left, right);
		sum = Math.max(sum, max);
		return sum;
	}

**因为每次递归都是当前长度一半 所以 递归时间复杂度为logn， 因为有for循环 所以 ，总的时间复杂度为 nlogn**

解法二 动态规划算法

		先定义状态 ， dp[i]  表示前 下标i之前(包含i)的最大子序列的和
		寻找递推关系
			  因为是连续子序列， 我们di[i] 必须要包含nums[i]
			  所以  我们就有了  当 dp[i - 1] < 0时， 前面所有数就对我们没有任何作用了。 所以dp[i] = nums[i]
			  								如果dp[i - 1] > 0, 那么前面的序列就对我们有作用， dp[i] = dp[i - 1] + nums[i]
		初始条件  很明显 dp[0]  = nums[0]

public int maxSubArray(int[] nums) {

		int[] dp = new int[nums.length];

		dp[0] = nums[0];

		int max = dp[0];
		for (int i = 1; i < nums.length; i++) {
			if (dp[i - 1] <= 0) {
				dp[i] = nums[i];
			} else {
				dp[i] = dp[i - 1] + nums[i];
			}
			if (dp[i] > max) {
				max = dp[i];
			}

		}
		return max;
	}

我们可以清晰的看出动态规划时间复杂度为 n, 是非常好的算法