您的位置:首页 > 其它

求最大子数组和问题

2017-08-03 17:10 176 查看
一个有N个整数元素的一维数组(A[0],A[1],…A[N-1]),这个数组有很多子数组,求子数组和的最大值?注意:子数组必须是连续的、不需要返回子数组的具体位置、数组中包含:正、负、零整数、子数组不能空。

例如:

int A[5] = {-1,2,3,-4,2};

符合条件的子数组为2,3,即答案为5;

穷举法:

public static int MaxSubStringSum(int[] array,int n) {
int sum,MaxSum =array[0];
/*i是数组的最左端*/
for(int i=0;i<n;i++) {
/*j是数组的最右端*/
for(int j =i;j<n;j++) {
//sum是array[i]到array[j]的子数组的和
sum = 0;
for (int k = i; k <= j; k++)
sum += array[k];
if(sum > MaxSum)//如果刚得到的这个子数组和更大
MaxSum = sum;//则更新结果
}
}
return MaxSum;
}
public static void main(String[] args) {
int[] array= new int[] {-1,2,3,-4,2};
int n = array.length;
int result= MaxSubStringSum(array,n);
System.out.println(result);
}


算法的时间复杂度为O(n^3)

优化: k在[i,j]区间内其实可以根据第二个区间算出sum

public static int MaxSubStringSum(int[] array,int n) {
int sum,MaxSum =array[0];
/*i是数组的最左端*/
for(int i=0;i<n;i++) {
/*j是数组的最右端*/
sum = 0;
for(int j =i;j<n;j++) {
sum += array[j];
MaxSum = Math.max(MaxSum,sum);
}
return MaxSum;
}


时间复杂度为O(n^2)

进一步分析:

我们利用穷举法虽然简单易懂,但是其时间复杂度很大,我们试着优化。现在考虑数组的第一个元素A[0],与和最大的子数组(A[i],……A[j])之间的关系,有以下三种关系:

1) i = j = 0;A[0]本身构成和最大的子数组 max {A[0]}

2) j > i = 0;和最大的子数组以A[0]开头 max{A[0]+TempMaxSum[1]}

3) i > 0;A[0]与和最大子数组没有关系 max{MaxSum[1]}

从上面3中情况可以看出,可以将一个大问题(N个元素的数组)转化为一个较小的问题(N - 1个元素的数组)。假设已经知道(A[1],……A[N-1])中和最大的子数组和为MaxSum[1],并且知道,(A[1],……A[N-1])中包含A[1]的和最大的子数组为TempMaxSum[1]。我们就可以把(A[0],……A[N-1])求和最大子数组问题转换为,MaxSum[0] = max{A[0],A[0]+TempMaxSum[1],MaxSum[1]}。

public static int MaxSubStringSum(int[] array,int n) {
int MaxSum = array[0];
int sum = array[0];
/*i从1开始*/
for(int i = 1;i < n;i++)
{
sum = Math.max(array[i],sum + array[i]);
MaxSum = Math.max(MaxSum,sum);
}
return MaxSum;
}


上面一种算法的思想已经接近动态规划求子问题的思想,来看看动态规划是如何实现的:

动态规划:

/*动态规划   核心思想:一旦发现子数组的和为负数,弃置,重新一个新数组。*/
public static int MaxSubStringSum(int[] array,int n) {
int MaxSum = 0;
int sum = 0;
for(int i = 0;i < n;i++)  {
sum +=array[i];
MaxSum= Math.max(MaxSum, sum);
if(sum < 0)
sum = 0;
}
return MaxSum;
}


分治法实现:分而治之 (未完待续)
内容来自用户分享和网络整理,不保证内容的准确性,如有侵权内容,可联系管理员处理 点击这里给我发消息
标签: