求连续子数组的最大和

本文参考July博客，学习用途：

求连续子数组的最大和

解法1.  三重循环暴力破解（时间复杂度O（n^3））

解法2. 难以理解july解法（其实是没有思路）（时间复杂度O（n））

   

public class sumofarr {
	public static void main(String[] args) {
		int arr[]= {1, -2, 3, 10, -4, 7, 2, -5};
		System.out.println(maxsum(arr));
		
	}
	
	static int maxsum(int[] arr){
		int max= arr[0];
		int sum =0;
		
		int lengthOfArr = arr.length;
		
		for(int j=0;j<lengthOfArr;j++){
			if(sum>0)
				sum+=arr[j];
			else
				sum=arr[j];
			if(sum>max)
				max=sum;
		}
		return max;
	}
}

解法3.

动态规划（时间复杂度O（n））

        static int maxs(int[] arr){
		int lengthOfArr  = arr.length;
		int[] sum = new int[lengthOfArr];
		sum[0] = arr[0];
		int result = arr[0];
		
		for(int i=0;i<lengthOfArr-1;i++){
			//动态规划，其实上面的解法与下面的有点关系。
			sum[i+1] = max(arr[i+1],sum[i]+arr[i+1]);
			result = max(result,sum[i+1]);
		}
		return result;
	}

上述三种解法其实都难以理解（从思路上说的）

在王晓东的计算机算法与分析一书上P60有一个分治法，该法对于理解动态规划法很有帮助：

至于 王晓东的树上面的 关于最大子段和问题的动态规划算法从分治里面借鉴思想，主要就借鉴了一个：定一端，分治是定了中间，从center + 1 ， center开始两端遍历，而动态规划是定结尾（定后端，从数学式出发推导，得到递归式）实现算法如上述解法2，上述解法2和3是一样的，下面给出分治法：

解法4.

分治 ，时间复杂度 O（nlogn）

	static int maxSubSum(int[] arr, int left, int right){
		int sum =0;
		// 递归结束条件：left == right
		if(left == right ) sum = arr[left]>0?arr[left]:0;
		else{
			int center = (left+right)/2;
			// case 1 : arr[left:center]最大子段和
			int leftsum = maxSubSum(arr,left,center);
			// case 2 : arr[center+1:right]最大子段和
			int rightsum = maxSubSum(arr,center+1,right);
			
			int s1 =0 ;
			int lefts =0;
			for(int i=center;i>=left;i--){
				lefts += arr[i];
				// 定一端，定中点，从center向 left遍历，找出以center为终点的最大子段
				if(lefts>s1) s1= lefts;
			}
			
			
			int s2= 0;
			int rights=0;
			for(int i=center+1;i<=right;i++){
				rights += arr[i];
				// 定一端，定中点，从center向 right遍历，找出以center为起点的最大子段
				if(rights >s2) s2 = rights;
			}
			// 上述两子段相加
			// case 3
			sum =s1+s2;
			// 将 case 3 和 case 1 ， case 2 比较
			if(sum < leftsum) sum = leftsum;
			if(sum<rightsum) sum = rightsum;
		}
		// 得出结果
		// 动态规划的定j点，以j点为终点的想法恐怕是从以center为终点得出。这样想比较符合人的思路。
		return sum;
	}
	
	static int maxSum(int[] arr){
		return maxSubSum(arr,0,arr.length-1);
	}

现在，回到 July博客：

July的第二节给出的四种解法，第二种解法无详细看，其余三种解法一样。

下面给出所有JAVA代码：

public class sumofarr {
	public static void main(String[] args) {
		int arr[]= {1, -2, 3, 10, -4, 7, 2, -5};
		// 动态规划
		System.out.println(maxsum(arr));
		// 动态规划
		System.out.println(maxs(arr));
		// 分治法
		System.out.println(maxSum(arr));
	}
	
	static int maxsum(int[] arr){
		int max= arr[0];
		int sum =0;
		
		int lengthOfArr = arr.length;
		
		for(int j=0;j<lengthOfArr;j++){
			if(sum>0)
				sum+=arr[j];
			else
				sum=arr[j];
			if(sum>max)
				max=sum;
		}
		return max;
	}
	
	static int maxs(int[] arr){
		int lengthOfArr  = arr.length;
		int[] sum = new int[lengthOfArr];
		sum[0] = arr[0];
		int result = arr[0];
		
		for(int i=0;i<lengthOfArr-1;i++){
			//动态规划，其实上面的解法与下面的有点关系。
			sum[i+1] = max(arr[i+1],sum[i]+arr[i+1]);
			result = max(result,sum[i+1]);
		}
		return result;
	}
	
	static int max(int a, int b){
		return a>b?a:b;
	}
	
	static int maxSubSum(int[] arr, int left, int right){
		int sum =0;
		// 递归结束条件：left == right
		if(left == right ) sum = arr[left]>0?arr[left]:0;
		else{
			int center = (left+right)/2;
			// case 1 : arr[left:center]最大子段和
			int leftsum = maxSubSum(arr,left,center);
			// case 2 : arr[center+1:right]最大子段和
			int rightsum = maxSubSum(arr,center+1,right);
			
			int s1 =0 ;
			int lefts =0;
			for(int i=center;i>=left;i--){
				lefts += arr[i];
				// 定一端，定中点，从center向 left遍历，找出以center为终点的最大子段
				if(lefts>s1) s1= lefts;
			}
			
			
			int s2= 0;
			int rights=0;
			for(int i=center+1;i<=right;i++){
				rights += arr[i];
				// 定一端，定中点，从center向 right遍历，找出以center为起点的最大子段
				if(rights >s2) s2 = rights;
			}
			// 上述两子段相加
			// case 3
			sum =s1+s2;
			// 将 case 3 和 case 1 ， case 2 比较
			if(sum < leftsum) sum = leftsum;
			if(sum<rightsum) sum = rightsum;
		}
		// 得出结果
		// 动态规划的定j点，以j点为终点的想法恐怕是从以center为终点得出。这样想比较符合人的思路。
		return sum;
	}
	
	static int maxSum(int[] arr){
		return maxSubSum(arr,0,arr.length-1);
	}
}

本次学习完。