chapter 4 分治策略

4 分治策略

4.1 最大子数组问题

假定我们要寻找数组A[low,...,high]中的最大子数组，使用分治法意味着要将数组A分成A[low,..,mid]和A[mid+1,...,high]，最大子数组可能存在三种情况：

1）完全位于子数组A[low,...,mid]中，因此low <= i <= j <= mid

2）完全位于子数组A[mid+1,...,high]中，因此mid < i <= j <=high

3）跨越了中点，因此low <= i <= mid < j <= high

分别求取上面三种情况下的最大子数组，然后比较三者的大小，去最大的情况作为最终结果。

跨越中点的最大和子列伪代码：

FIND-MAX-CROSSING-SUBARRAY(A, low, mid, high)

1. left-sum = -nan
2. sum = 0
3. for i = mid downto low
4.      sum = sum + A[i]
5.      if sum > letf-sum
6.           left-sum = sum
7.           max-left = i
8. right-sum = -nan
9. sum = 0
10. for i = mid + 1 downto high
11.      sum = sum + A[i]
12.      if sum > right-sum
13.           right-sum = sum
14.           max-right = i
15. return (max-left, max-rght, left-sum + right-sum)

求解最大子列数组的分治法伪代码：

FIND-MAXIMUM-SUBARRAY(A, low, high)

1. if high == low
2.      return (low, high, A[low]
3. else mid = (low + high) / 2
4.      (left-low, left-high, left-sum) =
5.           FIND-MAXIMUM-SUBARRAY(A, low, mid)
6.      (right-low, right-high, right-sum) =
7.           FIND-MAXIMUM-SUBARRAY(A, mid+1, high)
8.      (cross-low, cross-high, cross-sum) =
9.           FIND-MAX-CROSSING-SUBARRAY(A, low, mid, high)
10. if left-sum >= right-sum and left-sum >= cross-sum
11.      return (left-low, left-high, left-sum)
12. elseif right-sum >= left-sum and right-sum >= cross-sum
13.      return (right-low, right-high, right-sum)
14. else return (cross-low, cross-high, cross-sum)

C++代码实现：

#include<iostream>
using namespace std;

class SubArray {
public:
	SubArray(){}
	SubArray(int x, int y, int z) :
		low(x), high(y), sum(z) {}
	int low, high;
	int sum;
};

SubArray find_max_cross_subarr(int* A, int low, int mid, int high) {
	int left_sum = INT_MIN, right_sum = INT_MIN;
	int sum = 0;
	int max_left, max_right;
	for (int i = mid; i >= low; i--) {
		sum += A[i];
		if (sum > left_sum) {
			left_sum = sum;
			max_left = i;
		}
	}
	sum = 0;
	for (int j = mid+1; j <= high; j++) {
		sum += A[j];
		if (sum > right_sum) {
			right_sum = sum;
			max_right = j;
		}
	}
	SubArray subarray{max_left, max_right, left_sum + right_sum};
	return subarray;
}

SubArray find_max_subarr(int* A, int low, int high) {
	int mid;
	SubArray subarray, subarray_left, subarray_right, subarray_cross;
	if (high == low)
		return subarray = { low, high, A[low] };
	else {
		mid = (low + high) / 2;
		subarray_left = find_max_subarr(A, low, mid);
		subarray_right = find_max_subarr(A, mid + 1, high);
		subarray_cross = find_max_cross_subarr(A, low, mid, high);
	}
	if (subarray_left.sum >= subarray_right.sum && subarray_left.sum >= subarray_cross.sum)
		return subarray_left;
	else if (subarray_right.sum >= subarray_left.sum && subarray_right.sum >= subarray_cross.sum)
		return subarray_right;
	else return subarray_cross;
}

int main()
{
	int A[] = { 2, 4, -2, 5, 5, -10, 9 };
	SubArray subarray;
	int low = 0;
	int high = sizeof(A) / sizeof(A[0]) - 1;
	subarray = find_max_subarr(A, low, high);
	cout << subarray.low << " " << subarray.high << " " << subarray.sum << endl;
	return 0;
}

求解最大子列数组的暴力求解C++代码

#include<iostream>
using namespace std;

class SubArray {
public:
	SubArray(){}
	SubArray(int x, int y, int z) :
		low(x), high(y), sum(z) {}
	int low, high;
	int sum;
};

SubArray baoli_find_mum_sub(int* A, int low, int high){
	SubArray subarray;
	if (high == low)
		return subarray = { low, high, A[low] };
	int sum = 0;
	int max_sum = INT_MIN;
	int sub_low, sub_high;
	for (int i = low; i <= high; ++i){
		sum = 0;
		for (int j = i; j <= high; ++j){
			sum += A[j];
			if (sum > max_sum){
				max_sum = sum;
				sub_low = i;
				sub_high = j;
			}
		}
	}
	return subarray = { sub_low, sub_high, max_sum };
}

int main()
{
	int A[] = { 2, -4, -2, 5, -5, 10, 9 };
	SubArray subarray;
	int low = 0;
	int high = sizeof(A) / sizeof(A[0]) - 1;
	subarray = baoli_find_mum_sub(A, low, high);
	cout << subarray.low << " " << subarray.high << " " << subarray.sum << endl;
	return 0;
}