首页 > 代码库 > HDU1003 Max Sum 最大子序列和的问题【四种算法分析+实现】
HDU1003 Max Sum 最大子序列和的问题【四种算法分析+实现】
就拿杭电OJ上的第1003题开始吧，这题比原书要复杂一些。
Problem Description
Given a sequence a[1],a[2],a[3]......a[n], your job is to calculate the max sum of a sub-sequence. For example, given (6,-1,5,4,-7), the max sum in this sequence is 6 + (-1) + 5 + 4 = 14.
Input
The first line of the input contains an integer T(1<=T<=20) which means the number of test cases. Then T lines follow, each line starts with a number N(1<=N<=100000), then N integers followed(all the integers are between -1000 and 1000).
Output
For each test case, you should output two lines. The first line is "Case #:", # means the number of the test case. The second line contains three integers, the Max Sum in the sequence, the start position of the sub-sequence, the end position of the sub-sequence. If there are more than one result, output the first one. Output a blank line between two cases.
Sample Input
2
5 6 -1 5 4 -7
7 0 6 -1 1 -6 7 -5
Sample Output
Case 1:
14 1 4
Case 2:
7 1 6
题意很简单，那么就开始分析了，最容易想到的方法自然是枚举，只需要枚举出所有的可能情况。
具体实现如下：
#include <stdio.h>
#define maxn 100000 + 2
int arr[maxn];
int main(){
int t, n, maxLeft, maxRight, maxSum, id = 1;
int thisSum;
scanf("%d", &t);
while(t--){
scanf("%d", &n);
for(int i = 0; i < n; ++i)
scanf("%d", &arr[i]);
maxSum = arr[0];
maxLeft = maxRight = 0;
/*maxSubsequenceSum------O(N^3)*/
for(int i = 0; i < n; ++i){
for(int j = i; j < n; ++j){
thisSum = 0;
for(int k = i; k <= j; ++k){
thisSum += arr[k];
}
if(thisSum > maxSum){
maxSum = thisSum;
maxLeft = i; maxRight = j;
}
}
}
printf("Case %d:\n%d %d %d\n", id++, maxSum, maxLeft + 1, maxRight + 1);
if(t) printf("\n");
}
return 0;
}结果是意料之中的超时
接下来我们再换一个效率高点的算法。其实上一个算法中第三层for循环可以去掉，让第二层表示以arr[i]为起点的子序列，就这样一直向右加下去，如果和大于maxSum,那么就更新值。实现如下：
#include <stdio.h>
#define maxn 100000 + 2
int arr[maxn];
int main(){
int t, n, maxLeft, maxRight, maxSum, id = 1;
int thisSum;
scanf("%d", &t);
while(t--){
scanf("%d", &n);
for(int i = 0; i < n; ++i)
scanf("%d", &arr[i]);
maxSum = arr[0];
maxLeft = maxRight = 0;
/*maxSubsequenceSum------O(N^2)*/
for(int i = 0; i < n; ++i){
thisSum = 0;
for(int j = i; j < n; ++j){
thisSum += arr[j];
if(thisSum > maxSum){
maxSum = thisSum;
maxLeft = i;
maxRight = j;
}
}
}
printf("Case %d:\n%d %d %d\n", id++, maxSum, maxLeft + 1, maxRight + 1);
if(t) printf("\n");
}
return 0;
}依旧超时
只能再换效率更高算法，对于最大子序列和这个问题其实可以细分成多个子问题来求解，再将子问题的解合并，于是可以考虑下分治法，具体实现如下：
#include <stdio.h>
#define maxn 100000 + 2
int arr[maxn];
int t, n, maxLeft, maxRight, maxSum, id = 1;
int max3(int a, int b, int c){
if(a >= b && a >= c) return 1;
if(b >= a && b >= c) return 2;
if(c >= a && c >= b) return 3;
}
int maxSubsequenceSum(int left, int right, int *l, int *r){
int thisLeft, thisRight;
int leftSum, rightSum, midSum, mid;
int leftBorderSum, maxLeftBorderSum;
int rightBorderSum, maxRightBorderSum;
int ll, lr, rl, rr, ml, mr;
if(left == right){
*l = *r = left;
return arr[left];
}
mid = (left + right) / 2;
leftSum = maxSubsequenceSum(left, mid, &ll, &lr);
rightSum = maxSubsequenceSum(mid + 1, right, &rl, &rr);
leftBorderSum = 0; thisLeft = mid;
maxLeftBorderSum = arr[mid];
for(int i = mid; i >= left; --i){
leftBorderSum += arr[i];
if(leftBorderSum >= maxLeftBorderSum){
maxLeftBorderSum = leftBorderSum;
thisLeft = i;
}
}
rightBorderSum = 0; thisRight = mid + 1;
maxRightBorderSum = arr[mid + 1];
for(int i = mid + 1; i <= right; ++i){
rightBorderSum += arr[i];
if(rightBorderSum > maxRightBorderSum){
maxRightBorderSum = rightBorderSum;
thisRight = i;
}
}
midSum = maxLeftBorderSum + maxRightBorderSum;
int sign = max3(leftSum, midSum, rightSum);
if(sign == 1){
maxSum = leftSum;
*l = ll;
*r = lr;
}else if(sign == 2){
maxSum = midSum;
*l = thisLeft;
*r = thisRight;
}else{
maxSum = rightSum;
*l = rl;
*r = rr;
}
return maxSum;
}
int main(){
scanf("%d", &t);
while(t--){
scanf("%d", &n);
for(int i = 0; i < n; ++i)
scanf("%d", &arr[i]);
maxSum = arr[0];
maxLeft = maxRight = 0;
maxSubsequenceSum(0, n - 1, &maxLeft, &maxRight);
printf("Case %d:\n%d %d %d\n", id++, maxSum, maxLeft + 1, maxRight + 1);
if(t) printf("\n");
}
return 0;
}终于AC了！
书上还介绍了一个狂拽酷炫叼炸天的O(n)算法，这里也尝试一下，再对比一下与分治法的时间消耗。改的过程真是相当得不顺利，WA了5次左右才改对，不过把数组开销都省了，真心够精简的。
#include <stdio.h>
int main(){
int t, n, maxLeft, maxRight, maxSum, temp;
int thisLeft, thisSum;
scanf("%d", &t);
for(int id = 1; id <= t; ++id){
scanf("%d", &n);
scanf("%d", &maxSum);
thisLeft = maxLeft = maxRight = 0;
thisSum = maxSum;
if(thisSum < 0){ thisSum = 0; thisLeft = 1; }
for(int i = 1; i < n; ++i){
scanf("%d", &temp);
thisSum += temp;
if(thisSum > maxSum){
maxSum = thisSum;
maxLeft = thisLeft;
maxRight = i;
}
if(thisSum < 0){
thisLeft = i + 1;
thisSum = 0;
}
}
printf("Case %d:\n%d %d %d\n", id, maxSum, maxLeft + 1, maxRight + 1);
if(id != t) printf("\n");
}
return 0;
}时间开销如下
呼呼，四种算法总算都实现了。实现过程虽然很受挫，但是很充实的说，结果也很让人愉快，A wonderful day~
声明：以上内容来自用户投稿及互联网公开渠道收集整理发布，本网站不拥有所有权，未作人工编辑处理，也不承担相关法律责任，若内容有误或涉及侵权可进行投诉： 投诉/举报 工作人员会在5个工作日内联系你，一经查实，本站将立刻删除涉嫌侵权内容。