动态规划最大子数组和例题详解

静态的算法，比如说冒泡排序，我们可以很简单的知道它就是两个循环进行遍历，从i = 1 到 i = 2 ,以此类推的，思路可以很清晰，可以很直观的得出来最终结果。
然而在动归中，我们无法轻松的根据知道i的值来判断最大值是怎么得到的，因为他与i的值没有直接的关联，是每一步都建立在上一步求出来的结果上，再进一步扩大范围并融入上一步的结果。
静态是把所有的情况列出来，然后找出最优解，但是动态是分析的每一步都是为了得到局部最优解，自然最后的结果就是最终的最优解。

例题：最大子数组和问题
一个有N个整数元素的一位数组(A[0], A[1],…,A[n-1], A[n])，这个数组当然有很多子数组，那么数组之和的最大值是什么呢？
思路1:穷举法（也可以称之为静态）
使用类似于冒泡排序的方法，来遍历所有数之间的情况。当然这样的话，虽说也可以得出来最后结果，但是很显然这并不是最优的算法。

#include<iostream>
using namespace std;

int MaxString(int *A,int n);

int main()
{
    int A[100];
    int n;
    cin >> n;
    for(int i = 0 ; i < n ; i++)
        cin >> A[i];
    cout << MaxString(A, n) << endl;
    return 0;
}

int MaxString(int *A,int n)
{
    int max = INT_MIN;
    for(int i = 0 ; i < n ; i++)
    {
        int sum = 0;
        for(int j = i ; j < n ; j++)
        {
            sum += A[j];
            if(sum > max) max = sum;
        }
    }
    return max;
}

思路2:动态规划
我们已经知道第一个数的这段数组中子数组最大的和为All[0],并且已经知道(A[0],…,A[n-1])中包含A[0]的和最大的一段数组为Start[0]

1. 当0 = i = j 时，元素A[0]本身构成和最大的一段;
2. 当0 = i < j 时，和最大的一段以A[0]开始;
3. 当0 < i 时， 元素A[0]和最大的一段没有关系。

那么分析上述三种情况就不难看出 (A[0], …, A[n])中问题的解All[n - 1] = max{ A[n - 1], A[n - 1] + start[n - 1], All[n - 2] }。而All[0] = Start[0] = A[0].
All[n - 2]第一个数到第n - 2个这段数组中子数组最大的和

从A[0]到A[n]和最大的一段数组为Start[n]

从第一个数开始，往后面列举。
例如1 -2 3 4 -3 4
当i = 0时， start[0] = A[0]，all[0] = A[0];
当i > 0 && i < n - 1时，start[i] = max(A[i],A[i] + start[i - 1]);
all[i] = max(start[i],all[i - 1]);

拿刚才的例子遍历一遍应该就比较清晰了。
从已知的第一个数的all开始往后面推，每增加一个元素就求出这个元素之前最大的字数组之和。
也就是拿某个数（i），与这个数(i) + 从A[0]到A[i - 1]和最大的一段数组为start[i - 1]来进行比较(即如果start[i - 1] > 0时，则加上后边的子数组，否则不加)，得出这个数的最大子数组值，再拿这个数的最大子数组值与上一个数的最大子数组值进行比较。
1 -2 3 5 -3 4
start[1] = max(-2,-1) = -1;
all[1] = max(-1,1) = 1;

start[2] = max(3,2) = 3;
all[2] = max(3,1) = 3;

start[3] = max(5,8) = 8;
all[3] = max(8,3) = 8;

start[4] = max(-3,5) = 5;
all[4] = max(5,8) = 8;

start[5] = max(4,9) = 9;
all[5] = max(9,8) = 9;

最后的结果是9

#include<iostream>
using namespace std;

int MaxString(int *A,int n);
int main()
{
    int A[100];
    int n;
    cin >> n;
    for(int i = 0 ; i < n ; i++)
        cin >> A[i];
    cout << MaxString(A,n) << endl;
    return 0;
}

int MaxString(int *A,int n)
{
    int start[n];//从A[0]到A[n]和最大的一段数组为Start[n]
    int all[n];//第一个数到第n个数这段数组中子数组最大的和
    start[0] = A[0];
    all[0] = A[0];
    for(int i = 1 ; i < n; i++)
    {
        start[i] = max(A[i],A[i] + start[i - 1]);//如果Start[i - 1] > 0时，则加上后边的子数组，否则不加
        all[i] = max(start[i],all[i - 1]);
    }
    return all[n - 1];
}