[编程之美] 2.14 求数组的子数组之和的最大值

问题描述：给定一个包含N个整数的数组，求数组的子数组之和的最大值。

这是递归和贪心策略的一个经典问题。现在，对这个问题进行一下总结。

1 明确题意

题目中的子数组要求是连续的，也就是数组中的某个连续部分。

如果数组中都是正整数，直接相加就行。因此，主要是要考虑负数的情况。

2 直接求所有的子数组和

最简单且容易理解的解法是求出所有的子数组和，然后保存最大的和。

int MaxSum(int *A, int n)
{
    int maximum = -INF;
    int sum = 0;
    int i = 0, j = 0;

    for(i = 0; i < n; ++i) {

        sum = 0;

        for(j = i; j < n; ++j) {

            sum += A[j];

            if(sum > maximum) {
                maximum = sum;
            }
        }
    }

    return maximum;
}

3 递归

将数组分成长度相等的两部分：A[0]~A[n/2-1]和A[n/2]~A[n-1]。

那么对原数组而言，子数组和最大的子数组要么出现在A[0]~A[n/2-1]中，要么出现在A[n/2]~A[n-1]，要么子数组包含A[n/2-1]和A[n/2]并向左右延伸。

这就变成了递归：

#include <iostream>
#include <algorithm>
#include <limits>
#include <vector>
using namespace std;

int MaxSum(vector<int>::iterator beg, vector<int>::iterator end)
{
    if(end <= beg) {
        return 0;
    }

	if(beg + 1 == end) {
		return *beg;
	}

	vector<int>::difference_type len = end - beg;
	vector<int>::iterator mid = beg + len / 2;

	int left = MaxSum(beg, mid - 1);
	int right = MaxSum(mid, end);
	int sum1 = 0, maximum = numeric_limits<int>::min();

	for(vector<int>::iterator iter = mid - 1; iter != beg - 1; --iter) {

		sum1 += *iter;

		if(sum1 > maximum) {
			maximum = sum1;
		}
	}
    sum1 = maximum;

	int sum2 = 0;
    maximum = numeric_limits<int>::min();
	for(vector<int>::iterator iter = mid; iter != end; ++iter) {

		sum2 += *iter;

		if(sum2 > maximum) {
			maximum = sum2;
		}
	}
    sum2 = maximum;

	return max(max(left, right), sum1 + sum2);
}

int main(int argc, char const *argv[])
{
	vector<int> vec;

	vec.push_back(0);
	vec.push_back(-2);
	vec.push_back(3);
	vec.push_back(5);
	vec.push_back(-1);
	vec.push_back(2);

	cout << MaxSum(vec.begin(), vec.end()) << endl;

	return 0;
}

4 动态规划

假设已知A[0]~A[n-1]的子数组的和的最大值为m[n-1]，而以A[n-1]结束的子数组的和的最大值为s[n-1]，于是有：

（1）以A[n]为结束的子数组要么包含A[n-1]要么不包含A[n-1]，如果包含A[n-1]，那么以A[n]结束的子数组的和的值就是s[n - 1] + A[n]，如果不包含A[n - 1]，那么A[n]就是一个重新开始计算的地方，即当前只包含A[n]，于是有：s[n] = max(A[n], A[n] + s[n-1]); 

（2）同样有，A[0]~A[n]的子数组要么以A[n]结束要么不以A[n]结束，如果以A[n]结束，子数组的和就是s[n]，如果不以A[n]结束，子数组的和就是m[n - 1]，于是有：m[n] = max(s[n], m[n - 1]);

根据上面的两个递推式就有：

int MaxSum(vector<int>::iterator beg, vector<int>::iterator end)
{
    if(end <= beg) {
        return 0;
    }

    vector<int>::difference_type len = end - beg;
    vector<int> m, s;
    m.resize(len);
    s.resize(len);
    s[0] = *beg;
    m[0] = *beg;

    vector<int>::iterator m_iter = m.begin() + 1, s_iter = s.begin() + 1;
    for(vector<int>::iterator iter = beg + 1; iter != end; ++iter) {
        *s_iter = max(*iter, *iter + *(s_iter - 1));
        *m_iter = max(*s_iter, *(m_iter -1 ));
        ++m_iter;
        ++s_iter;
    }

    return m.back();
}

再来好好看看上面两个递推式：

s[n] = max(A[n], A[n] + s[n-1]);

m[n] = max(s[n], m[n - 1]);

从这两个递推式可以看出，如果已知s[n-1]、m[n-1]和A[n]就可以求得s[n]和m[n]，因此，事实上，只需要用两个变量来保存中间结果，而不需要用两个数组。

代码与上面的基本类似，就不再列出来了。

5 贪心

同时，从上面的两个递推式还可以看出，如果s[n-1] >= 0，就将A[n]放到当前考虑的子数组中，如果s[n-1] < 0，就从A[n]开始重新计算一个子数组。

这实际上使用的是贪心策略，不过贪心策略要经过严格的证明，这里还是可以从动态规划的方式来理解。于是有得到了史上最精简代码：

 

int MaxSum(vector<int>::iterator beg, vector<int>::iterator end)
{
    if(end <= beg) {
        return 0;
    }

    int maximum = numeric_limits<int>::min();
    int cur = 0;

    for(vector<int>::iterator iter = beg; iter != end; ++iter) {

        if(cur >= 0) {
            cur += *iter; 
        }
        else {
            cur = *iter;
        }

        if(cur > maximum) {
            maximum = cur;
        }
    }

    return maximum;
}

如果当前计算的子数组和>=0，就将当前遍历的数组成员加到里面；如果当前计算的子数组和<0，就从当前遍历的数组成员开始计算。

6 小结

本文给出了求子数组之和的最大值的四种方法，前面两种方法容易思考，代码略长且时间复杂度较高；后面两种方法不容易理解，但是代码简单且时间复杂度低。

其中的关键是先引出s[n]和m[n]，得到子数组之和的最大值的递推式，然后再通过递推式来简化算法。