[算法导论-分治策略]求最大子数组之各种解法及源代码实现

/*
问题： 已知数组 A = {2,4,-1,-5,3,-4,2,-6,4,1,2,2,4,-2,2};
求： 最小子数组和

分析：

一：  分治法：把问题分解成若干个简单易解的小问题，最后再把小问题归并起来，找到我们原来要解决问题的解

本问题中，我们把问题分解成两个规模尽量相等的子问题。 A[low...mid] 和 A[mid+1...high]
那最小的子数组和长啥样呢？
1： 子数组完全位于左子数组中 A[low...mid]
2: 子数组完全位于右子数组中 A[mid+1...high]
3:　子数组介于左子数组与右子数组之间

前两种情况我们有可以归到原来的问题上，对他们再次进行分解
而最后一种就需要我们做出特殊处理

（伪代码摘自 《算法导论》）
这个是求解 情况3 的算法
Find_Max_Crossiong_Subarray(A,low,mid,high)
left_sum = -无穷 //左数组最大和
sum = 0 // 临时变量
for i = mid downto low // 第一个 for 循环找出左子数组中最大子数组和
sum = sum + A[i]
if sum > left_sum
left_sum = sum
max_left = i;

right_sum = -无穷
sum = 0;
for j = mid+1 to high // 第二个 for 循环找出右子数组中最大子数组和
sum = sum + A[j]
if sum > right_sum
right_sum = sum
max_right = j;

return (max_left, max_right, left_sum + right_sum);

Find_Maximun_subarray(A, low, high)
if high == low
return (low, high, A[low])
else mid = (low+high)/2
(left_low,left_high,left_sum) = Find_Maximun_subarray(A, low, mid)
(right_low,right_high,tight_sum) = Find_Maximun_subarray(A, mid+1, high)
(cross_low, cross_high, cross_sum) = Find_Maximun_subarray(A,low,mid,high)
if left_sum >= right_sum and left_sum >= cross_sum
return (left_low, left_high, left_sum)
else if right_sum >= left_sum and right_sum >= cross_sum
return (right_low, right_high, right_sum)
else
return (cross_low, cross_high, cross_sum)

二： 扫描法

此种方法是这类问题的最优解法。时间复杂度是 O（n）。 上面的分治算法时间复杂度是 O（nlogn）

算法实现：

int FindMaxinumSubarray1(int * A, int low, int high)
{
int Sum = 0;
int temp = 0;

for (int i = low; i <= high; i++)
{
temp += A[i];
if (temp > Sum)
Sum = temp;
if (temp < 0)
temp = 0;
}

问题就是该怎么来理解这个分段：

例如：  一开始，我们另 Sum为 负无穷，这样我们可以保证至少有一个分段的总和是大于 Sum ,并会把分段中的结果temp赋值给Sum。

     如 下标i=0 时， temp += A[0] ,  即 temp = 2。 

ps:  temp 每一次更新值，都要做两次判断

1： 判断 是否要更新 Sum 的值，即子数组最大和的值

2： 判断 是否要更新 temp的值。 每当 temp 的值被累计到 负数 时， 就更新temp的值，令 temp = 0

temp 大于 此时的 Sum ， 即 Sum 被更新，  Sum = temp,   Sum = 2   (当前最大子数组和)

temp 大于0， 继续累加

i = 1 ,  temp += A[1] ,   即 temp = 6 

temp 大于 Sum , 更新 Sum，   Sum = temp ,   Sum = 6  (当前最大子数组和)

temp 大于 0 ， temp 继续累加

.........

当 i = 5 时，  A[i] = -4 

此时 temp = -1 小于 0 ， 即 temp 要被更新 ,  temp = 0

........

ps : 其他解决这类问题的算法还有 动态规划法和暴力破解法。

下面是C语言代码实现

#include<stdio.h>
#include<malloc.h>
#include<stdlib.h>
int* FindMaxCrossingSubarray(int* A, int low, int mid, int high);  //寻找跨越中点的最大子数组
int* FindMaximunSubarray(int*A , int low, int high);    // 寻找没有跨越中点的最大子数组
void Print(int *A,int length);  //打印结果


int FindMaxinumSubarray1(int*A, int low, int high); 


int main()
{
	int A[] = {2,4,-1,-5,3,-4,2,-6,4,1,2,2,4,-2,2};
	int *p = A;
	Print(p,15);

	p = FindMaximunSubarray(A,0,14);
	for (int i = 0; i < 3; i++)
	{
		printf("%d ",*(p+i));
	}

	printf("-----------------------------\n");
	printf("%d  ",FindMaxinumSubarray1(A,0,14));

	system("pause");
	return 0;
}

int * FindMaxCrossingSubarray(int * A, int low, int mid, int high)
{
	int LeftSum = INT_MIN;
	int Sum = 0;
	int MaxLeft = mid;
	for (int i = mid; i >= low; i--)
	{
		Sum = Sum + *(A+i);
		if (Sum > LeftSum)
		{
			LeftSum = Sum;
			MaxLeft = i;
		}
	}

	int RightSum = INT_MIN;
	int MaxRight = mid+1;
	Sum = 0;
	for (int j = mid + 1; j <= high; j++)
	{
		Sum = Sum + *(A+j);
		if (Sum > RightSum)
		{
			RightSum = Sum;
			MaxRight = j;
		}
	}
	
	int *re = (int*)malloc(sizeof(int)*3);
	*re = MaxLeft;
	*(re + 1) = MaxRight;
	*(re + 2) = LeftSum + RightSum;
	return re;
}

int * FindMaximunSubarray(int *A, int low, int high)
{
	if (low == high)
	{
		int *re = (int*)malloc(sizeof(int) * 3);
		*re = low;
		*(re + 1) = high;
		*(re + 2) = A[low];
		return re;
	}
	else
	{
		int mid = (low + high) / 2;
		int *Arr1 = FindMaximunSubarray(A, low, mid);
		int *Arr2 = FindMaximunSubarray(A,mid+1,high);
		int *Arr3 = FindMaxCrossingSubarray(A, low, mid, high);

		if (*(Arr1 + 2) > *(Arr2 + 2) && *(Arr1 + 2) > *(Arr3 + 2))
			return Arr1;
		else if (*(Arr2 + 2) > *(Arr1 + 2) && *(Arr2 + 2) > *(Arr3 + 2))
			return Arr2;
		else
			return Arr3;
	}

}

void Print(int * A, int length)
{
	int *q = A + length ;
	for (int* p = A; p < q; p++)
	{
		printf("%d ",*p);
	}


	/*for (int i = 0; i < length; i++)
	{
		printf("%d  ",*(A+i));
	}*/

	printf("\n");
}

int FindMaxinumSubarray1(int * A, int low, int high)
{
	int Sum = 0;
	int temp = 0;

	for (int i = low; i <= high; i++)
	{
		temp += A[i];
		if (temp > Sum)
			Sum = temp;
		if (temp < 0)
			temp = 0;
	}

	return Sum;
}