最大连续子数列求和的优化历程

最大子数列求和

今天在别人的博客里最大连续子数列和学到了很多，在此总结一下自己的学习历程

1.暴力递归 O(N²)

用数组sum[i]表示第1个到第i个数的和，用sum[j] - sum[i-1]表示第i个到第j个这个数列的和，省掉最内层的循环，C语言代码如下：

#include <stdio.h>

//N是数组长度，num是待计算的数组，sum是数组前缀和，放在全局区是因为可以开很大的数组
int N, num[16384], sum[16384];

int main()
{
    //输入数据
    scanf("%d", &N);
    for(int i = 1; i <= N; i++)
        scanf("%d", &num[i]);
    
    //计算数组前缀和
    sum[0] = 0;
    for(int i = 1; i <= N; i++) {
        sum[i] = num[i] + sum[i - 1];
    }

    int ans = num[1]; //ans保存最大子数列和，初始化为num[1]能保证最终结果正确
    //i和j分别是枚举的子数列的起点和终点
    for(int i = 1; i <= N; i++) {
        for(int j = i; j <= N; j++) {
            int s = sum[j] - sum[i - 1];
            if(s > ans) ans = s;
        }
    }
    printf("%d\n", ans);

    return 0;
}

依照博主的意思，还可以再优化一下，用num数组直接去存和，代替sum素组：

#include <stdio.h>
int N, num[16384];

int main() {
	//输入数据
	scanf("%d", &N);
	for(int i = 1; i <= N; i++) {
		scanf("%d", &num[i]);//计算数组前缀和
		num[i] = num[i] + num[i - 1];
	}
	
	int ans = num[1]; //ans保存最大子数列和，初始化为num[1]能保证最终结果正确
	//i和j分别是枚举的子数列的起点和终点
	for(int i = 1; i <= N; i++) {
		for(int j = i; j <= N; j++) {
			int s = num[j] - num[i - 1];
			if(s > ans) ans = s;
		}
	}
	printf("%d\n", ans);

	return 0;
}

2.分治算法优化时间复杂度 O(N*lg N)

分而治之，即利用函数的递归调用来解决此问题
用一个函数，将一个数组以中心位置为分割点，分两个部分，答案可以分为三种情况：
1.最大子数列在左边
2.在右边
3.横跨分割点，左边右边各占一部分。

遇到1，2种情况，可以递归，直到出现第三种情况为止。
处理第3种情况：
1.以分割点为起点，分别找出左边和右边的最大值（由于确定了的起点，所以复杂度不高），相加即可。
思路如此清晰，那么我们要做的是只是判断是哪种情况即可，这也并非问题，可以继续用递归调用求出1、2的最大子数列，然后与分割点左右两边的最大值比较即可

int solve(int left,int right,int *num) {//左值，右值，数组地址 
	if(left==right) {//递归结束 
		return num[right];
	}
	int mid=right+left>>1;
	int lans =solve (right,mid,num);//Left Answer，即left max 
	int rans = solve (mid+1,left,num);//Right Answer

	int sum = 0, lmax = num[mid], rmax = num[mid + 1];
	for(int i = mid; i >= left; i--) {
		sum += num[i];
		if(sum > lmax) lmax = sum;
	}
	sum = 0;
	for(int i = mid + 1; i <= right; i++) {
		sum += num[i];
		if(sum > rmax) rmax = sum;
	}

	//答案是三种情况的最大值
	int ans = lmax + rmax;
	if(lans > ans) ans = lans;
	if(rans > ans) ans = rans;

	return ans;
}

3.动态规划优化时间复杂度 O(N)

在学习动态规划之后，最大子数列和问题的时间复杂度得到了有效的优化。

假设数组f[i]表示带有第i项的最大子数列，遍历一遍f[i]即可找到答案。

通过观察可知：

f[i] = max( f[i-1] , 0) + a[i] ;

对于f[i]的前项f[i-1]，f[i]只有取和不取的两种选择，那么选大的就行。

依照这个思路，我们就可以写出以下代码：

#include<iostream>
using namespace std;
int a[1<<16] , ans[1<<16] ;
int main(){
	int n , maxn = -(1<<30);
	cin >> n;
    //读取
	for(int i = 1 ; i <= n ; i++)
		cin >> a[i];
    //构造含有a[i]的最大子数列ans[i]，同时寻找最大值
	for(int i = 1 ; i <= n ; i++){
		ans[i] = max(ans[i-1] , 0 ) + a[i];
		maxn = max( maxn , ans[i]); 
	}
	cout << maxn <<endl;
	return 0 ;
}

时间复杂度成功优化到了O(N)！让我们进行下一…稍等，好像还能稍稍优化一下，读取步骤和构造步骤似乎能同时进行，没有影响：

#include<iostream>
using namespace std;
int a[1<<16] , ans[1<<16] ;
int main(){
	int n , maxn = -(1<<30);
	cin >> n;
	for(int i = 1 ; i <= n ; i++){
		cin >> a[i];
		ans[i] = max(ans[i-1] , 0 ) + a[i];
		maxn = max( maxn , ans[i]); 
	}
	cout << maxn <<endl;
	return 0 ;
}

好！做了个小优化，很舒服！

4.优化空间复杂度O(1)

在以下递推表达式中

f[i] = max( f[i-1] , 0) + a[i] ;

真正能同时用到的变量只有f[i]，f[i-1]，和a[i]，其他变量都是用一次就丢弃了

所以，我们只需要设少量变量交替使用就可以了：

#include<iostream>
using namespace std;
int main(){
	int n , now , sum ,ans;
    /*
    n 数字个数
    now 当前的数字
    sum 带上当前数字的最大子数列
    ans 准备输出的答案
    */
	cin >> n;
	cin >> now;
	sum = ans = now;//必须先读取一个now赋上初值
	for(int i = 1 ; i < n ; i++)
	{
		cin >> now;
		sum = max(sum , 0) + now;
		ans = max(sum , ans);
	}
	cout << ans ; 
} 

从时间空间双O(N²)优化到了时间O(N)，空间O(1)，算法真是太有魅力了！
本篇博客于4月24日补充