最大m段子序列和问题:
一段数列中,选取m段不重叠的子序列,要求其总和最大. 区别于 最大子序列合
这类问题还是动态规划.
定义 dp[ i ] [ j ] 为 前面 j 个数字中选取 i 段 的最大和 ( 并且最后一段的结尾是第 j 个数字 ).
那么我们对于第 j 个数字我们有两种决策,一是加入到最后一段, 二是独立成新段.
针对这两种决策我们可以得出状态转移方程式 dp [ i ] [ j ] = max { dp [ i ] [ j-1 ] ,dp[ i-1 ] [ k ] } + num [ j ] ;( i -1 <= k <= j - 1) 注意 dp [ i ] [ j ] 中要保证 j>=i ,不然没有意义.
然后 ans = max {dp[ m ] [ k ] } ( m<=k<=n);
对于这种算法我们可以知道 从枚举 i: 0…m ; j: 0…n ; k: i-1…j-1; 时间复杂度接近于 O(m*n^2),空间复杂度为O(m*n);
我们可以发现对于每个 dp [ i ] [ j ] 的递推,我们只需要dp [ i ] [ j-1 ] and dp[ i-1 ] [ k ] 那么我们可以利用滚动数组把空间复杂度降为 O(n);
接着我们继续看,对于每个 dp [ i ] [ j ] 的递推的时候,我们求了一遍 dp [ i ][ j ] = max{dp[ i-1 ] [ k ],dp[ i ][ j-1 ] } ( i-1<=k<= j-1 )
而在递推 dp [ i ] [ j+1 ] 的时候我们只需要比较 dp [ i ][ j ] 和 dp [ i-1 ] [ j+1 ],而不需要在循环求一次dp [ i ][ j+1 ] = max{dp[ i-1 ] [ k ],dp[ i ][ j ] } ( i-1<=k<= j )
那么我们可以用降为 DP [ j ] 前面 j 个数字当前的最大子序列和 即是DP[j]=max{dp[ i ] [ k ]} ( i<=k<=j )
这个时候我们就可以把时间复杂度降到O(m*n);
下面上代码:(下面的 dp 数组就是上文的 DP 数组)
#include <stdio.h>
int dp[1000005],num[1000005],n,m;
int max(int a,int b)
{
return a>b ? a:b;
}
int solve()
{
for(int i=1;i<=m;i++)
{
int step=0;
for(int k=1;k<=i;k++)
step+=num[k];
dp[n]=step;
for(int j=i+1;j<=n;j++)
{
step=max(step,dp[j-1])+num[j];
dp[j-1]=dp[n];
dp[n]=max(step,dp[n]); //如果为最多m段的最大子序列和,那么我们可以建立一个max变量,在这里记录每个阶段dp[n],找到最大的dp[n];
}
}
return dp[n];
}
int main()
{
while(scanf("%d%d",&m,&n)!=EOF)
{
for(int i=1;i<=n;i++)
{
dp[i]=0;
scanf("%d",&num[i]);
}
printf("%d\n",solve());
}
return 0;
}