动态规划法解最大子数组问题

分治法https://www.cnblogs.com/zuofaqi/p/9678356.html 引入了最大子数组问题，它有一个更高效的解决方法就是动态规划法

如果已经知道 A[0...i] 的最大子数组，那么 A[0...i+1] 的最大子数组要么是 A[0...i] 的最大子数组，要么是某个子数组 A[j...i+1] (0<= j <= i+1)

动态规划三要素：

1. 边界：当数组中只有一个元素的时候，最大子数组就是自身

2. 最优子结构：A[0...i+1] 的最优子结构是 A[0...i] 和 A[j...i+1]

3. 状态转移方程：max_arr(A[0...i+1]) = max(A[0...i], A[j...i+1])

根据这个思路，就可以写出代码了

double max_arr(double* arr, int index, int& low, int& high)
{
    if (0 == index)
    {
        low = high = 0;
        return arr[0];
    }

    int pre_low, pre_high;
    double pre_sum = max_arr(arr, index-1, pre_low, pre_high);

    // 找 A[j...i+1]中最大的一个
    double maxsum = arr[index] - 1;
    for (int i = index; i >= 0; i--)
    {
        double cursum = 0;
        for (int j = index; j >= i; j--)
        {
            cursum += arr[j];
        }
        if (cursum > maxsum)
        {
            maxsum = cursum;
            low = i;
        }
    }

    // 比较两个最优子结构的数组和，取最大的一个
    if (maxsum > pre_sum)
    {
        high = index;
        return maxsum;
    }
    else
    {
        low = pre_low;
        high = pre_high;
        return pre_sum;
    }
}

 

还有一种思路，Kadane方法：

也是动态规划思想，max_ending_here表示：索引为i时候，最大的子数组为 1.如果以前的最大子数组是负值，取 arr[i]  2.否则取以前的max_ending_here+arr[i]

max_so_far 表示这些局部最大子数组中的最大值，也就是全局最大子数组

double max_arr(double* arr, int len)
{
    double max_ending_here = 0;
    double max_so_far = 0;

    for (int i = 0; i < len; i++)
    {
        max_ending_here = max(max_ending_here + arr[i], arr[i]);
        max_so_far = max(max_so_far, max_ending_here);
    }

    return max_so_far;
}