编程之美：2.14 求数组的子数组之和的最大值和最小值（动态规划）

问题一：

一个有N个整数元素的一维数组（A[0],A[1]....,A[n-2],A[n-1]),求子数组之和的最大值是什么？

方法一：动态规划

问题描述符合动态规划最优子结构的要求。

设b[i]表示以a[i]结尾 的子数组的最大子段和（a[i]一定包含在b[i]中，即：

b[i]=max{sum(a[j~i])},其中0<=j<=i 因此对于数组a[0~n]的最大字段和为max{b[i]}，(0<=i<n)。(也就是计算到底以哪个元素结尾的子数组才是最优解

sum为子问题的最优解，引入A[i]后，要考虑是否包含A[i],对于包含A[i]的情况即求b[i]，因为要求是连续的子数组，所以要考虑是不是包含b[i-1]. b[i] =Max{b[i-1]+A[i], A[i]}。所以问题变成：A[0]~A[i]的最优解为Max{sum, b[i]} => Max{sum, Max{a[i], b[i-1]+a[i]}}

1. 包含a[i],即求b[i]的最大值，在计算b[i]时,可以考虑以下两种情况,因为a[i]要求一定包含在内，所以

     1) 当b[i-1]>0, b[i] = b[i-1]+a[i]

     2) 当b[i-1]<=0, b[i] = a[i], 当b[i-1]<=0，这时候以a[i]重新作为b[i]的起点。     

2. 不包含a[i],即a[0]~a[i-1]的最大值（即0~i-1局部问题的最优解),设为sum

最后比较b[i]和 sum(0~i-1)(b[0~i-1]中最大的一个）即,如果b[i] >sum ,即b[i]为最优解,然后更新sum的值.

在实现时，bMax代表 b[k], sum更新前代表前一步子问题的最优解，更新后代表当前问题的最优解。实现如下：   

 // 求数组的子数组之和的最大值.
        public static int GetMaxSubArrayValue(int[] array, out int start, out int end)
        {
            int s, e;
            start =end = s = e = 0;

            int sum= array[0];
            int bMax = array[0];     

            for (int i = 1; i < array.Length; i++)
            {
                if (bMax < 0) 
                {    //情况一。 b[i] = a[i]，当b[i-1]<=0，这时候以a[i]重新作为b[i]的起点。
                    bMax = array[i];
                    s = e = i;
                }
                else //情况二 b[i] = b[i-1]+a[i]，当b[i-1]>0时，这时候的b[i]中包含a[i]。
                {
                    bMax += array[i];
                    e = i;
                }

                // 情况三。不包含a[i]的情况,即a[0]~a[i-1]的最大值，设为sum.这种情况在计算b[i]之前已经计算处结果，保存在b[0~i-1]中。最后计算max{b[i]}时会考虑到。

                if (bMax > sum) //b[i]和 sum(0~i-1)(b[0~i-1]中最大的一个）即,看下哪个值更大,即为最优解,然后更新sum的值.
                {
                    sum = bMax;
                    start = s;
                    end = e;
                }
            }

            return sum;
        }

问题二：

一个有N个整数元素的一维数组（A[0],A[1]....,A[n-2],A[n-1]),求子数组之和的最小值是什么

问题描述符合动态规划最优子结构的要求。

设b[i]表示以a[i]结尾 的子数组的最小子段和（a[i]一定包含在b[i]中，即：

b[i]=min{sum(a[j~i])},其中0<=j<=i 因此对于数组a[0~n]的最小字段和为min{b[i]}，(0<=i<n)。(也就是计算到底以哪个元素结尾的子数组才是最优解

      // 求数组的子数组之和的最小值.
        public static int GetMinSubArrayValue(int[] array, out int start, out int end)
        {
            int s, e;
            start = end = s = e = 0;

            int sum = array[0];
            int bMin = array[0];

            for (int i = 1; i < array.Length; i++)
            {
                if (bMin > 0)
                {    ///情况一。 b[i] = a[i]，当b[i-1] > 0，这时候以a[i]重新作为b[i]的起点。
                    bMin = array[i];
                    s = e = i;
                }
                else ///情况二。 b[i] = b[i-1]+a[i]，当b[i-1]<0时，这时候的b[i]中包含a[i]。
                {
                    bMin += array[i];
                    e = i;
                }

                // 情况三。 不包含a[i]的情况,即a[0]~a[i-1]的最小值，设为sum.这种情况在计算b[i]之前已经计算处结果，保存在b[0~i-1]中。最后计算min{b[i]}时会考虑到。

                if (bMin < sum) //b[i]和 sum(0~i-1)(b[0~i-1]中最大的一个）即,看下哪个值更小,即为最优解,然后更新sum的值.
                {
                    sum = bMin;
                    start = s;
                    end = e;
                }
            }

            return sum;
        }