【CSP-S 2019】【洛谷P5665】划分【单调队列dp】

前言

$csp$时发现自己做过类似这道题的题目 ： P4954 [USACO09Open] Tower of Hay 干草塔
然后回忆了差不多$15min$才想出来。。。
然后就敲了$88pts$的部分分。当时的内存是$950MB$左右，写一个高精就炸内存了。

---

题目

2048 年，第三十届 CSP 认证的考场上，作为选手的小明打开了第一题。这个题的样例有 $n$ 组数据，数据从 $1 sim n$ 编号，$i$ 号数据的规模为 $a_i$。

小明对该题设计出了一个暴力程序，对于一组规模为 $u$ 的数据，该程序的运行时间为 $u^2$。然而这个程序运行完一组规模为 $u$ 的数据之后，它将在任何一组规模小于 $u$ 的数据上运行错误。样例中的 $a_i$ 不一定递增，但小明又想在不修改程序的情况下正确运行样例，于是小明决定使用一种非常原始的解决方案：将所有数据划分成若干个数据段，段内数据编号连续，接着将同一段内的数据合并成新数据，其规模等于段内原数据的规模之和，小明将让新数据的规模能够递增。

也就是说，小明需要找到一些分界点 $1 leq k_1 lt k_2 lt cdots lt k_p lt n$，使得

$sum_{i=1}^{k_1} a_i leq sum_{i=k_1+1}^{k_2} a_i leq cdots leq sum_{i=k_p+1}^{n} a_i$

注意 $p$ 可以为 $0$ 且此时 $k_0 = 0$，也就是小明可以将所有数据合并在一起运行。

小明希望他的程序在正确运行样例情况下，运行时间也能尽量小，也就是最小化

$(sum_{i=1}^{k_1} a_i)^2 + (sum_{i=k_1+1}^{k_2} a_i)^2 + cdots + (sum_{i=k_p+1}^{n} a_i)^2$

小明觉得这个问题非常有趣，并向你请教：给定 $n$ 和 $a_i$，请你求出最优划分方案下，小明的程序的最小运行时间。

---

思路：

假设我们现在已经划分为三个部分$x,y,z$满足$xleq yleq z$，那么显然是有
$x^2+y^2+z^2<x^2+(y+z)^2$
所以我们肯定要做到能分就分。
但是贪心选取肯定是错误的。样例一明显就指出了错误。
考虑$dp$。设$f[i]$表示我们划分$1sim i$的所有数，以$i$为最后一个区块的情况下，最后一个区块的最小长度。
那么枚举一个$j$，明显有
$f[i]=min(sum^{i}_{k=j}a_k) (sum^{i}_{k=j}a_kgeq f[j])$
由于$sum^{i}_{k=j}a_k$满足单调性，所以肯定选择尽量大的$j$来转移。
如果$j$可以转移到$i$，那么转移的同时可以求出划分的费用
$ans[i]=ans[j-1]+(sum^{i}_{k=j}a_k)^2$
这样我们就得到了一个$O(n^2)$的算法，可以得到$64pts$的高分。
我们发现，转移的条件$sum^{i}_{k=j}a_kgeq f[j]$其实就是$sum^i_{k=1}a_k-sum^i_{k=j}a_kgeq f[j]$，移项就得到了$sum^i_{k=1}a_kgeq f[j]+sum^i_{k=j}a_k$
我们发现，在做了前缀和之后，上式等号左边只与$i$有关，等号右边只与$j$有关。同时我们又要满足选择尽量大的$j$来转移，所以就可以维护一个单调队列装$f[j]+sum^i_{k=j}a_k$进行转移。
但是我们每次要选择的是满足$sum^i_{k=1}a_kgeq f[j]+sum^i_{k=j}a_k$的尽量大$j$进行转移，而不是单纯的最小的$sum^i_{k=1}a_kgeq f[j]+sum^i_{k=j}a_k$转移。所以我们每次要不断弹出队头，知道队头不再满足$sum^i_{k=1}a_kgeq f[j]+sum^i_{k=j}a_k$。此时将最后一次弹出的元素再从头部插入进行转移。这样就保证了每次选择$j$最大的满足条件的元素进行转移。容易证明，弹出的元素不会对后面的转移产生影响。
这样每个元素最多进入队列1次，时间复杂度$O(n)$。
这样我们就得到了$88pts$的高分。
对于$type=1$的数据点需要使用高精，但是由于$O(n)$的算法我们的内存已经使用了$950MB$，所以几乎没有空间来敲高精。
所以此时就只能用csp不允许使用的__int128了
我们将$ans$改为$\_\_int128$类型，是可以存下最终答案的。
然后我就愉快的T了。

在尝试过所有我知道的化学性卡常后，样例三依然需要$2.4s+$才可以跑过。
所以此时就只能用csp不允许使用的Ofast了
物理性卡常$nb$！样例最终可以在$0.85s$左右跑过。
然后我就愉快的MLE了。

经过输出后，$ans,f,sum$三个数组加起来是$1200+MB$。将近$200MB$的差距，只能考虑删除一个数组了。
$ans$和$sum$是肯定无法删除的，而$f$我们发现，在转移时是等于$sum[i]-sum[last]$的，其中$last$直可以转移的最大的$j$。
所以我们考虑直接用$sum$数组来表示出$f$数组。这样我们往单调队列插入时就要插入$i,f_i+sum_i$两维，因为后者在去掉$f$数组后是没办法算出来的。
最终还是以$1.38s,804.98MB$过了这道题。但是在$csp$时是不允许用$\_\_int128$和$Ofast$的，所以其实这份代码无论是时间还是空间都是过不去的

---

代码：

#pragma GCC optimize("Ofast")
#pragma GCC optimize("inline")
#include <queue>
#include <cstdio>
#include <string>
#include <cstring>
#include <algorithm>
#define mp make_pair
using namespace std;
typedef long long ll;

const int N=40000010,MOD=(1<<30),M=100010;
int n,x,type,cnt,id;
ll d,xx,yy,zz,m,sum[N],b[4],p[M],l[M],r[M];
__int128 ans[N];
pair<int,ll> last;
char ch;
deque<pair<int,ll> > q;

inline ll read()
{
	d=0; ch=getchar();
	while (!isdigit(ch)) ch=getchar();
	while (isdigit(ch))
		d=(d<<3)+(d<<1)+ch-48,ch=getchar();
	return d;
}

inline void write(__int128 x)
{
	if (x>9) write(x/10);
	putchar(x%10+48);
}

inline ll Get(int i)
{
	int id=(i-1)%3+1;
	if (i>2 && id==1) b[1]=(xx*b[3]+yy*b[2]+zz)%MOD;
	if (i>2 && id==2) b[2]=(xx*b[1]+yy*b[3]+zz)%MOD;
	if (i>2 && id==3) b[3]=(xx*b[2]+yy*b[1]+zz)%MOD;  //减少模运算次数
	if (i>p[cnt]) cnt++;
	return (b[id]%(r[cnt]-l[cnt]+1))+l[cnt];
}

int main()
{
	scanf("%d%d",&n,&type);
	if (type)
	{
		xx=read(); yy=read(); zz=read(); b[1]=read(); b[2]=read(); m=read();
		for (int i=1;i<=m;i++)
			p[i]=read(),l[i]=read(),r[i]=read();
	}	
	q.push_back(mp(0,0));
	for (register int i=1;i<=n;i++)
	{
		sum[i]=sum[i-1]+(type?Get(i):read());
		while (q.size() && sum[i]>=q.front().second)
		{
			last=q.front();
			q.pop_front();
		}
		q.push_front(last);
		int pos=last.first;
		ans[i]=ans[pos]+(__int128)(sum[i]-sum[pos])*(sum[i]-sum[pos]);
		while (q.size() && q.back().second>=sum[i]-sum[pos]+sum[i]) q.pop_back();
		q.push_back(mp(i,sum[i]-sum[pos]+sum[i]));
	}
	write(ans[n]);
	return 0;
}