分治策略 | 最大子数组问题

最新推荐文章于 2021-01-12 21:29:20 发布

Joy_Shen

最新推荐文章于 2021-01-12 21:29:20 发布

阅读量304

点赞数

分类专栏：数据结构与算法文章标签：分治策略最大子数组算法导论

本文链接：https://blog.csdn.net/index20001/article/details/77455629

版权

数据结构与算法专栏收录该内容

11 篇文章 0 订阅

订阅专栏

分治策略就是把一个大问题递归地分解成规模较小的子问题，子问题的规模可能不等。

最大子数组问题，找数组A中和最大的连续段A[i, .., j]。A中要有负数这个问题才有意义。

伪代码：

（跨中点的情况）

（完全在原数组左边或右边的情况）

C++代码：

#include <iostream>

using namespace std;

struct maxSubarray 
{
	int low;
	int high;
	int sum;
};

maxSubarray findMaxCrossingSubarray(int* arr, int low, int mid, int high)
{
	int sum = 0;
	int leftSum = -65535;
	int rightSum = -65535;
	maxSubarray crossSub;
	crossSub.low = low;
	crossSub.high = high;
	for (int i = mid; i >= low; i--)
	{
		sum += arr[i];
		if (sum > leftSum)
		{
			leftSum = sum;
			crossSub.low = i;
		}
	}
	sum = 0;
	for (int i = mid + 1; i <= high; i++)
	{
		sum += arr[i];
		if (sum > rightSum)
		{
			rightSum = sum;
			crossSub.high = i;
		}
	}
	crossSub.sum = leftSum + rightSum;
	return crossSub;
}

maxSubarray findMaxmumSubarray(int* arr, int low, int high, int sum)
{
	if (low == high)
	{
		maxSubarray sub;
		sub.low = low;
		sub.high = high;
		sub.sum = arr[low];
		return sub;
	}
	else
	{
		int mid = (low + high) / 2;
		maxSubarray leftSub;
		leftSub = findMaxmumSubarray(arr, low, mid, sum);
		maxSubarray rightSub;
		rightSub = findMaxmumSubarray(arr, mid + 1, high, sum);
		maxSubarray crossSub;
		crossSub = findMaxCrossingSubarray(arr, low, mid, high);
		if (leftSub.sum >= rightSub.sum && leftSub.sum >= crossSub.sum)
			return leftSub;
		else if (rightSub.sum >= leftSub.sum && rightSub.sum >= crossSub.sum)
			return rightSub;
		else if (crossSub.sum >= leftSub.sum && crossSub.sum >= rightSub.sum)
			return crossSub;
	}
}

int main()
{
	int A[10] = { 4, 5, 7, -2, -3, -6, -1, 9, -2, 4 };
	maxSubarray maxSub;
	maxSub = findMaxmumSubarray(A, 0, sizeof(A) / sizeof(A[0]) - 1, -65535);
	cout << maxSub.low << "," << maxSub.high << "," << maxSub.sum << endl;
	return 0;
}

---------- 更新分治策略写法 (上面的代码是何等的woc...) ----------

int maxSubArray(vector<int>& nums) {
    if (nums.empty())
        return 0;
    return findMaxSubArray(nums, 0, nums.size() - 1);
}

int findMaxSubArray(vector<int>& nums, int left, int right) {
    if (left >= right) return nums[left];
    int mid = left + (right - left) / 2;
    int lmax = findMaxSubArray(nums, left, mid - 1);
    int rmax = findMaxSubArray(nums, mid + 1, right);
    int mmax = nums[mid], temp = mmax;               //跨中点数组
    for (int i = mid - 1; i >= left; --i) {
        temp += nums[i];
        mmax = max(mmax, temp);
    }
    temp = mmax;
    for (int i = mid + 1; i <= right; ++i) {
        temp += nums[i];
        mmax = max(mmax, temp);
    }
    return max(mmax, max(lmax, rmax));
}

习题中也介绍了一种方法，线性时间O(n)指的是已知A[1,..,j]的最大子数组再求A[1,..,j+1]的最大子数组，但如果看整体的时间复杂度，还是O(n^2)，不如分治法好。