最大连续子序列和（状态的无后效性）——附带完整实现代码

1 问题描述

给定一个数字序列A₁.A₂,…,A_n，求i,j ( 1 <= i <= j <= n),使得A_i+…+A_j最大，输出这个最大和。

例如：
-2 11 -4 13 -5 -2
显然11 + (-4) + 13 之和最大，最大和为20

如果使用暴力，枚举左端点和右端点，需要时间复杂度O(n²),而计算A[i]+…+A[j]需要O(n)的复杂度，因此总复杂为O(n³).

就算采用记录前缀和方法，令S[i] = A[0] + A[i], 这样A[i] +…+A[j]=S[j] -S[i-1]，来计算的时间变为O(1),总复杂度仍然有O(n²),对于n为10⁵的题目，还是不能接受。

用动态规划就可以把时间复杂度降低为O(n),【左端点的枚举根本没有必要】，

• 1 用dp[i]表示A[i]结尾的连续序列最大和（A[i]必须为连续序列的末尾）【不然就会产生多个相同的dp[i]】
  • 以-2 11 -4 13 -5 -2为例子（下标从0开始）
  • dp[3] = 20(计算过程：11+(-4) + 13)
  • dp[4] = 15(计算过程：11+(-4) + 13+(-5)), 如果A[i]不为连续序列的末尾，则值就会为20
• 2 dp为必须以A[i]为连续序列的结尾的序列，最大和有两种情况
  • 最大序列和只有一个元素，即以A[i]开始，以A[i]结尾
  • 最大序列和有多个元素，从前面某出A[p]开始(p<i)，一直到A[i]结尾。
• 3 因此状态转移方程为：
  • dp[i] = max (A[i], d[i -1] + A[i]);
• 4 这个方程只与i和i前面的元素有关，且边界dp[0] = A[0],由此从小到大枚举i，来得到全部的数组dp

2 实现代码

2.1 暴力实现

#include<cstdio>

int maxSum(int *A, int n){
    int sum = A[0];
    for(int i = 0; i < n;i++){//遍历数组
        for(int j = i;j < n; j++){//确定前缀和的基准元素（即以它往前的元素）
            int tmp = 0;
            for(int k = i;k <= j;k++){//计算A[i~j]之间的数组和
                tmp += A[k]; 
            }
            if(tmp > sum) sum = tmp; 
        }
    }
    return sum;
}

int main(){
    //int A[] = {-2, -5, -1, -3};
    int A[] = {1, -2, 3, 10, -4, 7, 2, -5};
    printf("%d", maxSum(A, sizeof(A)/sizeof(A[0])));
    return 0;
}

时间复杂度：O(n³)
空间复杂度：O(1)

2.2简单实现

#include <cstdio>
#include <algorithm>

using std::max;

const int MAXN = 1000;
int A[MAXN];//序列
int dp[MAXN];//dp[i]存放以A[i]为结尾的连续序列最大和

int main(int argc, char const *argv[])
{
    int n;
    scanf("%d", &n);
    for (int i = 0; i < n; ++i)
    {
        scanf("%d", &A[i]);
    }

    //边界
    dp[0] = A[0];
    for (int i = 1; i < n; ++i)
    {
        //状态转移方程
        dp[i] = max(A[i], dp[i- 1] + A[i]);
    }

    int index = 0;
    for (int i = 1; i < n; ++i)
    {
        if(dp[i] > dp[index]){
            index = i;
        }
    }

    printf("%d\n", dp[index]);
    return 0;
}

Sample Input:
6
-2 11 -4 13 -5 -2
Sample Output:
20

2.3 提炼为一个函数

#include<cstdio>
int maxSum(int *A, int n){//求最大连续子序列之和
    int dp, sum;//dp为当前的子序列和，sum为最大子序列和
    dp = sum = A[0];
    for(int i = 1;i < n ;i++){
        if(dp > 0){//A[i] + dp > A[i]
            dp = dp + A[i];
        }else{
            dp = A[i];
        }
        if(dp > sum) sum = dp;
    }
    return sum;
}

int main(){
    //int A[] = {-2, -5, -1, -3};
    int A[] = {1, -2, 3, 10, -4, 7, 2, -5};
    printf("%d", maxSum(A, sizeof(A)/sizeof(A[0])));
    return 0;
}

时间复杂度：O(n)
空间复杂度：O(1)

3 总结

状态的无后效性：当前状态记录了历史信息，一旦当前状态确定，就不会再改变，且未来的决策只能在已有一个或若干状态的基础上进行，历史信息只能通过已有的状态来影响未来的决策

⚠️： 并不是所有的状态都具有无后效性，如何设计状态和状态转移方程，才是动态规划的核心。