最大子段和问题：四种不同时间复杂度的算法

问题描述

给定一个序列，求出其元素和最大的一个子序列。如果序列所有元素为负数，那么规定最大和为0，最大子序列为空。注意子序列里的元素在原序列中是相邻的（不然的话只要把原序列所有正数找出来就行了）。

例

序列：[12, 5, -1, 31, -61, 59, 26, -53, 58, 97, -93, -23, 84, -15, 6]
最大子序列：[59, 26, -53, 58, 97]

穷举算法求解

穷举算法思想简单，只要把序列所有的子序列遍历一遍，分别求和，储存最大值。

第一种穷举算法：

int *Solve(int array[], int size) {
    int max_value = 0;
    int max_sub[2] = {0};
    for (int i = 0; i < size; i++) {
        for (int j = i; j < size; j++) {
            int sum = 0;
            for (int k = i; k <= j; k++)
                sum += array[k];
            if (sum > max_value) {
                max_value = sum;
                max_sub[0] = i;
                max_sub[1] = j;
            }
        }
    }
    return max_sub;
}

有三个for循环嵌套，显然，时间复杂度为$O(n^3)$。

改进后的穷举算法只有两个for循环：

int *Solve(int array[], int size) {
    int max_value = 0;
    int max_sub[2] = {0};
    for (int i = 0; i < size; i++) {
        for (int j = i, sum = 0; j < size; j++) {
            //并非每次都要把array[i]到array[j]的和重新算一遍，利用上一次的sum就行了
            sum += array[j];
            if (sum > max_value) {
                max_value = sum;
                max_sub[0] = i;
                max_sub[1] = j;
            }
        }
    }
    return max_sub;
}

时间复杂度为$O(n^2)$。

分治算法求解

我们可以这样将原问题分解：把要求的序列对半分成$a_0\sim a_{\frac{n}{2}}$和$a_{\frac{n}{2}}\sim a_n$两部分，假设已求出两部分的最大和子段为$a_{i1}\sim a_{j1}$、$a_{i2}\sim a_{j2}$，那么问题的解答一定是 m a x { a i 1 ∼ a j 1 , a i 2 ∼ a j 2 , a i 1 ∼ a j 2 } max\left \{a_{i1} \sim a_{j1}, a_{i2} \sim a_{j2},a_{i1} \sim a_{j2}\right \} max{ai1​∼aj1​,ai2​∼aj2​,ai1​∼aj2​}！即两个子问题的解答，或者把两个子问题解答连接起来中的一个。

由于解答的数据包括下标和求和结果，编程时，可以先定义一个结构体用来组织数据，方便数据传递。递归的思想是：如果传入的序列长度为1，那么返回对应元素的值（对一个元素求和那答案就是这个元素）和它的下标；否则，调用自己计算对半分的两个子序列的答案（不用担心长度是奇数，只要一个传size/2，一个传(size-size/2)就能保证不会漏掉元素了），然后按上述定义返回最大的值。

代码：

typedef struct answer {
    int sub_1;
    int sub_2;
    int sum;
} Answer;
Answer Solve(int array[], int size, int start_sub = 0, int end_sub = 0) {
    if (start_sub == 0 && end_sub == 0)
        end_sub = size - 1;
    if (size == 1) {
        Answer temp;
        temp.sub_1 = start_sub;
        temp.sub_2 = start_sub;
        temp.sum = array[start_sub];
        return temp;
    }
    Answer temp1, temp2, temp3;
    int this_sum = 0;
    temp1 = Solve(array, size / 2, start_sub, start_sub + size / 2 - 1);
    temp2 = Solve(array, size - size / 2, end_sub - (size - size / 2) + 1, end_sub);
    for (int i = temp1.sub_1; i <= temp2.sub_2; i++) {
        this_sum += array[i];
    }
    temp3.sub_1 = temp1.sub_1;
    temp3.sub_2 = temp2.sub_2;
    temp3.sum = this_sum;
    if (temp1.sum >= temp2.sum && temp1.sum >= temp3.sum)
        return temp1;
    else if (temp2.sum >= temp1.sum && temp2.sum >= temp3.sum)
        return temp2;
    else
        return temp3;
}

以上代码有更简洁的写法，因为size可以由end_sub-start_sub算出。

运用主方法易知时间复杂度是$O(n\log n)$。

动态规划算法

动态规划的思想是把原问题分成若干个不互相独立的子问题。

解决最大子段和问题的动态规划思想：

连续求和，如果求出的和为负数，那么在下一次求和时放弃之前的计算结果（求出负数说明序列扩展到这个元素时已经不可能是最大的子序列的成员了，因为最大和不会比0小的）。要找出最大和子序列，只要找和最大的那个下标，往前回溯到第一个不是负数的下标即可。

1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
12	5	-1	31	-61	59	26	-53	58	97	-93	-23	84	-15	6
12	17	16	47	-14	59	85	32	90	187	94	71	155	140	146

一目了然，答案就是[59, 26, -53, 58, 97]。

可以看出动态规划算法和分治算法最大的不同是，分治算法都是分成互相独立的子问题，不会像动态规划那样有一个数据结构来存储之前子问题的答案。

代码：

int *Solve(int array[], int size)
{
    int i = 0, b[size], max = array[0], max_sub[2] = {0};
    b[0] = array[0];
    for (int i = 1; i < size; i++) {
        b[i] = b[i - 1] + array[i];
        if (b[i] < 0)
            b[i] = array[i];
        if (b[i] > max) {
            max = b[i];
            max_sub[1] = i;
        }
    }
    for (i = max_sub[1]; ; i--) {
        if(b[i] < 0) {
            max_sub[0]=i + 1;
            break;
        }
        if(i==0) {
            max_sub[0]=0;
            break;
        }
    }
    return max_sub;
}

只有两个循环，没有循环的嵌套，时间复杂度为多项式时间$O(n)$。