动态规划的思想。
- 基本思路:
首先,定义
n u m [ n ] num[n] num[n] 用来存储 n n n 个整数组成的序列
d p [ i ] [ j ] dp[i][j] dp[i][j] 用来表示由前 j j j 项得到的含 i i i 个字段的最大值,且最后一个字段以 n u m [ j ] num[j] num[j] 项结尾。仔细想想,我们可以知道:
d p [ i ] [ j ] = max t = i − 1 j − 1 ( d p [ i ] [ j − 1 ] + n u m [ j ] , d p [ i − 1 ] [ t ] + n u m [ j ] ) dp[i][j]=\max\limits_{t=i-1}^{j-1}(dp[i][j-1]+num[j],dp[i-1][t]+num[j]) dp[i][j]=t=i−1maxj−1(dp[i][j−1]+num[j],dp[i−1][t]+num[j])
(因为必须是以 n u m [ j ] num[j] num[j] 结尾的,所以 n u m [ j ] num[j] num[j] 一定属于最后一个子段,即要么自己独立成一个子段,要么与前边以 n u m [ j − 1 ] num[j-1] num[j−1] 结尾的子段联合)
所求的最后结果为 max j = 1 n { d p [ m ] [ j ] } \max\limits_{j=1}^n\{dp[m][j]\} j=1maxn{dp[m][j]}
但是,我们会发现,当n非常大时,这个算法的时间复杂度和空间复杂度是非常高的,时间复杂度近似为 O ( m ∗ n 2 ) O(m*n^2) O(m∗n2)
空间复杂度近似为 O ( m ∗ n ) O(m*n) O(m∗n).
因此,我们需要优化算法来降低时间复杂度和空间复杂度
- 优化算法:
(1)节省时间
我们只要找到 d p [ i ] [ j − 1 ] dp[i][j-1] dp[i][j−1] 和 d p [ i − 1 ] [ t ] dp[i-1][t] dp[i−1][t] 的最大值加上 n u m [ j ] num[j] num[j] 即为 d p [ i ] [ j ] dp[i][j] dp[i][j]
所以,定义一个数组 p r e _ m a x [ n ] pre\_max[n] pre_max[n],用 p r e _ m a x [ j − 1 ] pre\_max[j-1] pre_max[j−1] 来表示求解 d p [ i ] [ j ] dp[i][j] dp[i][j] 时 d p [ i − 1 ] [ t ] dp[i-1][t] dp[i−1][t] 的最大值,
则 d p [ i ] [ j ] = m a x ( p r e _ m a x [ j − 1 ] , d p [ i ] [ j − 1 ] ) + n u m [ j ] dp[i][j]=max(pre\_max[j-1],dp[i][j-1])+num[j] dp[i][j]=max(pre_max[j−1],dp[i][j−1])+num[j]
特别注意, p r e _ m a x [ n ] pre\_max[n] pre_max[n] 这个位置的存储空间是始终用不到的,因此可以用来存储其他数值,在接下来会用到。
在求解 d p [ i ] [ j ] dp[i][j] dp[i][j] 的同时,我们可以计算出 max t = i j { d p [ i ] [ t ] } \max\limits_{t=i}^j\{dp[i][t]\} t=imaxj{dp[i][t]} ,
这个最大值在计算 d p [ i + 1 ] [ j + 1 ] dp[i+1][j+1] dp[i+1][j+1] 的时候需要作为 p r e _ m a x [ j ] pre\_max[j] pre_max[j] 的形式被使用,我们先把它存在 p r e _ m a x [ n ] pre\_max[n] pre_max[n] 中。
你可能会问:为什么不把它直接放在 p r e _ m a x [ j ] pre\_max[j] pre_max[j] 中呢?
因为你接下来需要计算 d p [ i ] [ j + 1 ] dp[i][j+1] dp[i][j+1] 的值,需要用到 p r e _ m a x [ j ] pre\_max[j] pre_max[j] 中原来的值,
如果你把它存在这里,就会覆盖掉计算 d p [ i ] [ j + 1 ] dp[i][j+1] dp[i][j+1] 所需要的那个值。所以,先把它放在 p r e _ m a x [ n ] pre\_max[n] pre_max[n] 中。
当我们计算完 d p [ i ] [ j + 1 ] dp[i][j+1] dp[i][j+1] 之后,就会发现 p r e _ m a x [ j ] pre\_max[j] pre_max[j] 中的值已经没有用处了,我们可以把它更新为计算 d p [ i + 1 ] [ j + 1 ] dp[i+1][j+1] dp[i+1][j+1] 所需要的那个值,
即之前放在 p r e _ m a x [ n ] pre\_max[n] pre_max[n] 中的那个值,即执行 p r e _ m a x [ j ] = p r e _ m a x [ n ] pre\_max[j]=pre\_max[n] pre_max[j]=pre_max[n].
这样我们就节省了计算最大值时付出的时间代价。
(2)节省空间
通过时间的节省,我们突然间发现程序执行结束后 p r e _ m a x [ n ] pre\_max[n] pre_max[n] 的值即为最后的结果, p r e _ m a x [ n ] pre\_max[n] pre_max[n] 数组才是我们希望求解的,
d p [ m ] [ n ] dp[m][n] dp[m][n] 这个庞大的数组已经不是那么重要了,因此,我们现在用整型数 t m p tmp tmp 来代替 d p [ m ] [ n ] dp[m][n] dp[m][n],用来临时存储 d p [ i ] [ j ] dp[i][j] dp[i][j] 的值,
作为求解 p r e _ m a x [ n ] pre\_max[n] pre_max[n] 的中介。
这样就节省了 d p [ i ] [ j ] dp[i][j] dp[i][j] 占用的极大的空间.
#include <map>
#include <set>
#include <ctime>
#include <queue>
#include <stack>
#include <cmath>
#include <vector>
#include <bitset>
#include <cstdio>
#include <cctype>
#include <string>
#include <numeric>
#include <cstring>
#include <cassert>
#include <climits>
#include <cstdlib>
#include <iostream>
#include <algorithm>
#include <functional>
using namespace std ;
//#define int long long
#define rep(i, a, b) for (int i = (a); i <= (b); i++)
#define per(i, a, b) for (int i = (a); i >= (b); i--)
#define loop(s, v, it) for (s::iterator it = v.begin(); it != v.end(); it++)
#define cont(i, x) for (int i = head[x]; i; i = e[i].nxt)
#define clr(a) memset(a, 0, sizeof(a))
#define ass(a, sum) memset(a, sum, sizeof(a))
#define lowbit(x) (x & -x)
#define all(x) x.begin(), x.end()
#define ub upper_bound
#define lb lower_bound
#define pq priority_queue
#define mp make_pair
#define pb push_back
#define fi first
#define se second
#define iv inline void
#define enter cout << endl
#define siz(x) ((int)x.size())
#define file(x) freopen(#x".in", "r", stdin),freopen(#x".out", "w", stdout)
typedef long long ll ;
typedef unsigned long long ull ;
typedef pair <int, int> pii ;
typedef vector <int> vi ;
typedef vector <pii> vii ;
typedef queue <int> qi ;
typedef queue <pii> qii ;
typedef set <int> si ;
typedef map <int, int> mii ;
typedef map <string, int> msi ;
const int N = 1000010 ;
const int INF = 0x3f3f3f3f ;
const int iinf = 1 << 30 ;
const ll linf = 2e18 ;
const int MOD = 1000000007 ;
const double eps = 1e-7 ;
void print(int x) { cout << x << endl ; exit(0) ; }
void PRINT(string x) { cout << x << endl ; exit(0) ; }
void douout(double x){ printf("%lf\n", x + 0.0000000001) ; }
int a[N], dp[N] ;
int n, m ;
int calc(int n, int m) {
rep(i, 1, m) {
int tmp = 0 ;
rep(k, 1, i) tmp += a[k] ;
dp[n] = tmp ;
rep(j, i + 1, n) {
tmp = max(dp[j - 1], tmp) + a[j] ;
dp[j - 1] = dp[n] ;
dp[n] = max(dp[n], tmp) ;
}
}
return dp[n] ;
}
signed main(){
while (scanf("%d%d", &m, &n) != EOF) {
rep(i, 1, n) scanf("%d", &a[i]), dp[i] = 0 ;
printf("%d\n", calc(n, m)) ;
}
return 0 ;
}
/*
写代码时请注意:
1.ll?数组大小,边界?数据范围?
2.精度?
3.特判?
4.至少做一些
思考提醒:
1.最大值最小->二分?
2.可以贪心么?不行dp可以么
3.可以优化么
4.维护区间用什么数据结构?
5.统计方案是用dp?模了么?
6.逆向思维?
*/