求连续子数组的最大和

本文参考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);
}
}

本次学习完。