算法导论例程——最大子数组问题

        最大子数组描述的是这样的一个问题：给定一个整型数组a[]，规模为n，求其中连续的m个元素之和使其最大。其中这m个元素被称为是数组a的子数组。

        最大子数组问题的求解过程可以分成三种情况，对给定数组，找到中点一分为二，它的最大子数组有可能在左边的部分，有可能在右边的部分，还有可能跨过(cross)左边和右边，那么对于最大子数组在左边或右边的情况，我们又可以把他们看作原问题的一个较小规模的子问题，即对左数组或右数组再次求最大子数组，那么这是递归问题的部分，它的基本问题是当待考察数组规模为1时，那么最大子数组就是它本身，这是递归的终止条件。接下来我们需要考虑的问题就是跨中点的子数组的问题。

        对于跨中点的最大子数组，我们可以设定max值，从中点起不断向两侧进行累加并与flag值比较，若大于flag值则替换，而flag值最初始时为一个广义的无穷小值，保证第一次循环时可以替换。

#include <stdio.h>
int max_subarray(int a[], int start, int end);
int max_crossing_subarray(int a[], int start, int mid, int end);

int main()
{
	int a[1000] = { 0 }, n = 0, i = 0, length = 0;
	printf("请输入待查找数组的规模：");
	scanf("%d", &n);
	length = n;
	while (n--)
		scanf("%d", &a[i++]);
	printf("%d\n", max_subarray(a, 0, length - 1));

	return 0;
}

int max_subarray(int a[], int start, int end)
{
	int mid, left_max, right_max, crossing_max;
	if (start == end)
		return a[start];
	else
	{
		mid = (start + end) / 2;
		left_max = max_subarray(a, start, mid);
		right_max = max_subarray(a, mid + 1, end);
		crossing_max = max_crossing_subarray(a, start, mid, end);

		if (left_max > right_max&&left_max > crossing_max)
			return left_max;
		else if (right_max > left_max&&right_max > crossing_max)
			return right_max;
		else
			return crossing_max;
	}
}

int max_crossing_subarray(int a[], int start, int mid, int end)
{
	int i = mid, j = mid + 1, sum = 0, left_sum = -10000, right_sum = -10000;
	for (i; i > start-1; i--)
	{
		sum += a[i];
		if (sum > left_sum)
			left_sum = sum;
	}
	
	sum = 0;                                                            //sum在进行新的计算的时候一定要初始化
	for (j; j < end + 1; j++)
	{
		sum += a[j];
		if (sum > right_sum)
			right_sum = sum;
	}

	return left_sum + right_sum;
}

          如果想要更精确的知道最大子数组的下标以及sum值，可以声明结构体变量，让两个函数的返回值为该结构体即可。

          接下来看dp的解法，非常巧妙。这里考察两个属性，一个是我们要求的最大子数组ms，一个是尾数组tms，其中tms[k,...i] = a[k] + ... + a[i]。我们不考虑整个数组中全是负数元素的情况，那么容易证明，ms和tms的最小值是0。对于数组规模为1的时候，ms = a[0]，tms = a[0]，而当数组规模大于1时，我们得到这样的关系：

          tms[i] = max{0,tms[i-1] + a[i]}

          ms[i] = max{tms[0],tms[1],...,tms[i]}

          也就是说，当尾数组不大于零时，他对于最大子数组是没有贡献的，而最大子数组其实就是尾数组中最大的。

#include <stdio.h>
int main()
{
	int a[1000] = { 0 }, i = 0, n = 0, length = 0, tail_max_subarray = 0, max_subarray = 0;
	printf("请输入待考察数组的规模：");
	scanf("%d", &n);
	length = n;
	while (n--)
		scanf("%d", &a[i++]);
	
	for (i = 0; i < length; i++)
	{
		tail_max_subarray += a[i];
		if (tail_max_subarray < 0)
			tail_max_subarray = 0;
		if (max_subarray < tail_max_subarray)
			max_subarray = tail_max_subarray;
	}
	printf("最大子数组sum值：%d\n", max_subarray);

	return 0;
}

         这样写完之后，复杂度一下子就降到o(n)。dp大法好。

         改进了之后的，支持全负数，可以输出起始位置。

#include <iostream>
using namespace std;
int main()
{
	int start = 0, end = 0, i = 0, tms = 0, ms = 0, T = 0, size = 0, a[100010] = { 0 }, num = 1, temp1 = 0;
	cin >> T;
	int temp = T;
	while (T--)
	{
		cin >> size;
		for (i = 1; i <= size; i++)
			cin >> a[i];
		tms = 0;
		ms = a[1];
		start = 1;
		end = 1;
		temp1 = 1;
		for (i = 1; i <= size; i++)
		{
			tms += a[i];
			if (tms > ms)
			{
				ms = tms;
				end = i;
				start = temp1;
			}
			if (tms <= 0)
			{
				tms = 0;
				temp1 = i + 1;
			}
		}
		cout << "Case " << num++ << ":" << endl << ms << " " << start << " " << end << endl;
		if (num <= temp)
			cout << endl;
	}
}