HDU 1003 Max Sum + 单调队列优化dp解法

首先贴上经典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');
	}
}