@bzoj - 4709@ 柠檬

目录

• @desription@
• @solution@
• @accepted code@
• @details@

---

@desription@

一共有 N 只贝壳，编号为 1...N，贝壳 i 的大小为 si。

Flute 每次可以取一段连续的贝壳，并选择 s0。如果这些贝壳中大小为 s0 的贝壳有 t 只，就通过魔法把这些贝壳变成 s0*t^2 只柠檬。

经过任意次魔法取完贝壳，最终 Flute 得到的柠檬数是所有小段柠檬数的总和。问最多能变出多少柠檬。

input

第 1 行：一个整数，表示 N（1 ≤ N ≤ 100,000）。

第 2 .. N + 1 行：每行一个整数，第 i + 1 行表示 si（1 ≤ si ≤10,000）。

output

仅一个整数，表示 Flute 最多能得到的柠檬数。

sample input

5

2

2

5

2

3

sample output

21

sample explain

Flute 先从取下 4 只贝壳，它们的大小为 2, 2, 5, 2。选择 s0 = 2，那么这一段

里有 3 只大小为 s0 的贝壳，通过魔法可以得到 2×3^2 = 18 只柠檬。再从右端取下最后一只贝壳，通过魔法可以得到 1×3^1 = 3 只柠檬。总共可以得到 18 + 3 = 21 只柠檬。没有比这更优的方案了。

@solution@

有这样一个性质：假如你对于区间 [l, r] 选的贝壳大小为 s0，则贝壳 l 与 r 的大小为 s0。

如果区间的左右端点的大小不为 s0，则你可以往内缩端点直到等于为止，此时这个区间的答案不会变化。

这样我们就可以来设计 dp 了。

定义状态 \(dp[i]\) 表示取完 1~i 这些贝壳所能求得的最大柠檬数，再定义 \(f[i]\) 表示 i 前面的，与 i 大小相同的贝壳数量（类前缀和）。

则有状态转移：

\[dp[i] = dp[j-1] + s[i]*(f[i]-f[j]+1)*(f[i]-f[j]+1) (s[i] = s[j]且j \leq i)
\]

长得非常 “斜率优化”，我们拆开括号再仔细来看一看：

\[dp[i] = dp[j-1] + s[i]*(f[i]+1)^2-2*s[i]*f[i]*f[j]+s[i]*f[j]^2
\]

注意 s[i] = s[j]。所以式子还可以变为：

\[dp[i] = (dp[j-1]+s[j]*f[j]^2) + (s[i]*(f[i]+1)^2)-2*s[i]*f[i]*f[j]
\]

然后就可以斜率优化了。其中横坐标 \(x[j] = 2*f[j]\)，纵坐标 \(y[j] = dp[j-1]+s[j]*f[j]^2\)，斜率 \(k[i]=s[i]*f[i]\)。

我们对于每一个 \(s[i]\) 分别进行斜率优化，斜率 \(s[i]*f[i]\) 是单增的，横坐标 \(2*f[j]\) 也是单增，求最大值即上凸包，对于每一个 \(s[i]\) 都开一个单调栈就 OK 了。

讲一点代码细节：同时维护多个单调栈可以不用 vector 或者 deque 等动态的存储，因为我们已知了所有不同类型的 si 对应的元素个数，所以它的单调栈长度必然不会超过这个值。

我们开一个总的长度为 N 的空间，然后按照元素个数分配栈顶的指针即可。

@accepted code@

#include<queue>
#include<cstdio>
#include<algorithm>
using namespace std;
typedef long long ll;
const int MAXN = 100000;
const int MAXS = 10000;
ll dp[MAXN + 5], sum[MAXN + 5];
int nxt[MAXN + 5], adj[MAXN + 5], s[MAXN + 5];
ll c(int i) {return (sum[i] + 1)*(sum[i] + 1)*s[i];}
ll k(int i) {return 2LL*s[i]*(sum[i] + 1);}
ll x(int j) {return sum[j];}
ll y(int j) {return dp[j-1] + sum[j]*sum[j]*s[j];}
double slope(int p, int q) {return 1.0*(y(p) - y(q))/(x(p) - x(q));}
int stk[MAXN + 5], tp[MAXS + 5], cnt[MAXS + 5];
int main() {
	int N; scanf("%d", &N);
	for(int i=1;i<=N;i++) {
		scanf("%d", &s[i]);
		sum[i] = sum[adj[s[i]]] + 1;
		nxt[i] = adj[s[i]];
		adj[s[i]] = i;
		cnt[s[i]]++;
	}
	for(int i=1;i<=MAXS;i++)
		cnt[i] += cnt[i-1];
	for(int i=1;i<=MAXS;i++)
		tp[i] = cnt[i-1];
	for(int i=1;i<=N;i++) {
		while( tp[s[i]] > cnt[s[i]-1] + 1 && slope(stk[tp[s[i]]], i) >= slope(stk[tp[s[i]] - 1], stk[tp[s[i]]]) )
			tp[s[i]]--;
		stk[++tp[s[i]]] = i;
		while( tp[s[i]] > cnt[s[i]-1] + 1 && slope(stk[tp[s[i]] - 1], stk[tp[s[i]]]) <= k(i) )
			tp[s[i]]--;
		dp[i] = c(i) + y(stk[tp[s[i]]]) - k(i)*x(stk[tp[s[i]]]);
	}
	printf("%lld\n", dp[N]);
}

@details@

一开始我想的是对于每一个 si 都从头到尾作一遍 dp，这样就只需要一个单调栈了。

后来发现，不同的 si 之间也会相互影响，所以我只能从前往后老老实实维护多个单调栈了……