首先贴上经典dp解法, 以i结尾的最大子段和 d[i] = max(d[i-1]+a[i], a[i]).
但这不是本文的主要目的.
代码 O(n) :
#include<cstdio>
#include<cstring>
#include<iostream>
#include<cmath>
#include<string>
#include<vector>
#include<map>
#include<algorithm>
using namespace std;
inline int Rint() { int x; scanf("%d", &x); return x; }
inline int max(int x, int y) { return (x>y)? x: y; }
inline int min(int x, int y) { return (x<y)? x: y; }
#define FOR(i, a, b) for(int i=(a); i<=(b); i++)
#define FORD(i,a,b) for(int i=(a);i>=(b);i--)
#define REP(x) for(int i=0; i<(x); i++)
typedef long long int64;
#define INF (1<<30)
const double eps = 1e-8;
#define bug(s) cout<<#s<<"="<<s<<" "
#define MAXN 100002
int a[MAXN];
int d[MAXN];
// dp: d[i] = max(d[i-1]+a[i], a[i]).
int main()
{
int T = Rint();
FOR(ca, 1, T)
{
printf("Case %d:\n", ca);
int n = Rint();
FOR(i, 1, n)
{
a[i] = Rint();
}
int st = 1, en = 1;
int ans_st = 1, ans_en=1;
memset(d, 0, sizeof(d));
int maxx = -INF;
FOR(i, 1, n)
{
d[i] = max(d[i-1]+a[i], a[i]);
if(d[i]==d[i-1]+a[i]) //output the first one
{
en = i;
}
else
{
st = i; // 就算d值没有更大, 但是也要记录下来st, 等到d值更大时更新给结果, 才会正确, wa1
en = i;
}
if(maxx<d[i])
{
ans_st = st;
ans_en = en;
maxx = d[i];
}
}
printf("%d %d %d\n", maxx, ans_st, ans_en);
if(ca!=T) putchar('\n');
}
}那主要目的是什么?....
我们来换一种思路, 考虑"连续",
容易得到, 前i个数能得到的最大子段和 d[i] = max{ max(d[j], sum[i]-sum[j]) }, j=[1, i-1]. 这个要O(n*n).
这时我们用单调队列优化, 先把状态改成 以i结尾的最大子段和 d[i] = max(sum[i]-sum[j]), j=[1, i-1]. 这样解变成max{d[i]}. 但是它方便我们维护最值
即d[i] = max(f[k])+sum[i], f[k] = -sum[k], k=[1, i-1].
OK了~化成这种形式就知道上单调队列了吧~
当然, 这其实也根本不用单调队列, 因为k的下界跟i无关, 一直是1, 换句话说就是没有下界. 所以我们可以扫一遍得到min{sum[k]}. 然后再扫一遍算出 max(sum[i]-min). 就行了.
但是我们还是用单调队列做一下, 主要是为下几篇对 k有限制的情况 做铺垫.
代码:
#include<cstdio>
#include<cstring>
#include<iostream>
#include<cmath>
#include<string>
#include<vector>
#include<map>
#include<algorithm>
using namespace std;
inline int Rint() { int x; scanf("%d", &x); return x; }
inline int max(int x, int y) { return (x>y)? x: y; }
inline int min(int x, int y) { return (x<y)? x: y; }
#define FOR(i, a, b) for(int i=(a); i<=(b); i++)
#define FORD(i,a,b) for(int i=(a);i>=(b);i--)
#define REP(x) for(int i=0; i<(x); i++)
typedef long long int64;
#define INF (1<<30)
const double eps = 1e-8;
#define bug(s) cout<<#s<<"="<<s<<" "
// 以i结尾的子串最大和d[i] = max(d[i-1]+a[i], a[i]). 这个状态方程可以很好地做到O(n).
// 但是 我们换一种思路, 把它看成"连续"的问题.
// 得 前i个数能得到的最大子段和 d[i] = max{ max(d[j], sum[i]-sum[j]) }, j=[1, i-1]. 这个要O(n*n).
// 这时我们用单调队列优化, 先把状态改成
// 以i结尾的最大子段和 d[i] = max(sum[i]-sum[j]), j=[1, i-1]. 这样解变成max{d[i]}. 但是它方便我们维护最值
// 即d[i] = max(f[k])+sum[i], f[k] = -sum[k], k=[1, i-1].
#define MAXN 100002
int sum[MAXN];
int d[MAXN];
int f[MAXN];
int q[MAXN];
int front, tail;
int main()
{
int T = Rint();
FOR(ca, 1, T)
{
printf("Case %d:\n", ca);
int n = Rint();
int maxd = -INF;
int st=1, en=1;
front = tail = 0;
f[0] = sum[0] = 0;
FOR(i, 1, n) //online
{
int t = Rint();
sum[i]=sum[i-1]+t;
f[i] = -sum[i];
// 把i-1丢进队列
while(front<tail && f[q[tail-1]]<f[i-1]) tail--;
q[tail++] = i-1;
// 用front 算 d[i]
int low = 0; //说白了就是无下界, 因为有边界, 把下界扩到0
while(q[front]<low) front++; //其实永远不会发生, 这里为了把过程写清楚点
d[i] = f[q[front]]+sum[i];
if(d[i]>maxd)
{
maxd = d[i];
st = q[front]+1;
en = i;
}
}
printf("%d %d %d\n", maxd, st, en);
if(ca!=T) putchar('\n');
}
}
