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

分治策略的说明

分治策略是将一个大问题，不断分解成多个容易解决、与大问题形式相同的小问题，然后将小问题的解组合一起来得出最终大问题的解。

在分治策略中将执行如下三个步骤：

分解：将大问题分解成多个与大问题形式相同的小问题

解决：如果问题的规模不够小则继续将小问题分解成更小的问题，如果问题的规模足够小，直接求解

合并：将小问题的解一层层地合并，最终得到大问题的解

实现分治策略的技术，通常是递归。

最大子数组问题

问题简单叙述：

给一个连续的数组，数组中既有正数也有复数。

数组中一个数或者连续的一组数称为子数组，求其和。

和最大的子数组，称为最大子数组。

暴力求解

最简单直接的方法就是逐个逐个子数组去检查，但时间复杂度是Θ(n²)

int find_max_subarray(int *arr, int len) {
    int max_sum = arr[0];
    for (int i = 0; i < len; i++) {
        int sum = 0;
        for (int j = i; j < len; j++) {
            sum += arr[j];
            if (sum > max_sum)
                max_sum = sum;
        }
    }
    return max_sum;
}

分治策略求解

分治策略要求将一个大问题分解成形式相同的小问题。

那么，在分解这个大数组的时候，要尽可能将大数组分解成两个长度相同的小数组，即从中间开始划分。

然后在左数组中寻找最大子数组，在右数组中寻找最大子数组，不断递归下去。

但是，又有另一个问题，如果最大子数组跨越了中间点，那又要单独考虑。

因此，在每次递归的时候需要解决三个问题：寻找左数组中的最大子数组，寻找右数组中的最大子数组，寻找跨越中间点的最大子数组。

这三个问题的解，最大的那个，就是最终的解。

利用分治策略求解，时间复杂度降到了O(nlgn)

int find_max_crossing_subarray(int *arr, int low, int mid, int high) {
int sum = 0;

int left_sum = arr[mid];
sum = 0;
for (int i = mid; i >= low; i--) {
sum += arr[i];
if (sum > left_sum)
left_sum = sum;
}

int right_sum = arr[mid + 1];
sum = 0;
for (int i = mid + 1; i <= high; i++) {
sum += arr[i];
if (sum > right_sum)
right_sum = sum;
}

return (left_sum + right_sum);
}

int find_max_subarray(int *arr, int low, int high) {
if (low == high)
return arr[low];

int mid = (low + high) / 2;

int left_max = find_max_subarray(arr, low, mid);
int right_max = find_max_subarray(arr, mid + 1, high);
int cross_max = find_max_crossing_subarray(arr, low, mid, high);

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

对比两种求解方式的差异

利用下面一段完整的代码计算两者的时间消耗

#include <cstdlib>
#include <ctime>
#include <iostream>
using namespace std;

int find_max_subarray(int *arr, int len) {
    int max_sum = arr[0];
    for (int i = 0; i < len; i++) {
        int sum = 0;
        for (int j = i; j < len; j++) {
            sum += arr[j];
            if (sum > max_sum)
                max_sum = sum;
        }
    }
    return max_sum;
}

int find_max_crossing_subarray(int *arr, int low, int mid, int high) {
    int sum = 0;

    int left_sum = arr[mid];
    sum = 0;
    for (int i = mid; i >= low; i--) {
        sum += arr[i];
        if (sum > left_sum)
            left_sum = sum;
    }

    int right_sum = arr[mid + 1];
    sum = 0;
    for (int i = mid + 1; i <= high; i++) {
        sum += arr[i];
        if (sum > right_sum)
            right_sum = sum;
    }

    return (left_sum + right_sum);
}

int find_max_subarray(int *arr, int low, int high) {
    if (low == high)
        return arr[low];

    int mid = (low + high) / 2;

    int left_max = find_max_subarray(arr, low, mid);
    int right_max = find_max_subarray(arr, mid + 1, high);
    int cross_max = find_max_crossing_subarray(arr, low, mid, high);

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

int main() {
    const int MAX = 100000;

    srand(time(0));
    int *arr = new int[MAX];
    for (int i = 0; i < MAX; i++) {
        arr[i] = rand() % 1000;
    }

    clock_t start_1 = clock();
    int result_1 = find_max_subarray(arr, MAX);
    clock_t end_1 = clock();
    cout << "The result: " << result_1 << endl;
    cout << "Time consuming: "
        << static_cast<double>(end_1 - start_1) / CLOCKS_PER_SEC << endl;

    clock_t start_2 = clock();
    int result_2 = find_max_subarray(arr, 0, MAX - 1);
    clock_t end_2 = clock();
    cout << "The result: " << result_2 << endl;
    cout << "Time consuming: "
        << static_cast<double>(end_2 - start_2) / CLOCKS_PER_SEC << endl;

    return 0;
}

输出结果是



在数据规模是10万的情况下，就能看出两者的巨大差异。

至此，能够初步看到分治策略解决问题的强大。

参考书籍

《算法导论》