【CSP-S2019】D2T2 划分

CSP-S2019 D2T2 划分

题目

题目描述

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

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

也就是说，小明需要找到一些分界点 $1\le k_1<k_2<?<k_p<n$，使得

$$\sum _{i=1}^{k_1}{a}_i\le \sum _{i=k_1+1}^{k_2}{a}_i\le ?\le \sum _{i=k_p+1}^n{a}_i$$

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

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

$${\left(\sum _{i=1}^{k_1}{a}_i\right)}^2+{\left(\sum _{i=k_1+1}^{k_2}{a}_i\right)}^2+?+{\left(\sum _{i=p+1}^n{a}_i\right)}^2$$

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

分析

结论： 最后取出的一段的长度要尽可能地小。

证明： 不会。。。如果想要看理性的证明可以去看 matthew99 的博客

然后这道题就变成水题了。。。

我还是说一下我的感性理解吧。。。

记 $s_i$ 为 $a_i$ 的前缀和。

首先不难想到一个 36 分的 DP：（这是我考场上想到的）

记 $f(i,j)$ 为把前 $i$ 个数分成 $j$ 段所产生的最小代价，$g(i,j)$ 为最后一段的右端点的位置。那么显然有转移：

f(i,j)=min?(k<i)∧(sk?sg(k,j?1)≤si?sk){f(k,j?1)+(si?sk)2}f(i, j) = \min\limits_{(k < i) \land (s_k - s_{g(k, j - 1)} \le s_i - s_k)} \{ f(k, j - 1) + (s_i - s_k)^2 \} f(i,j)=(k<i)∧(sk??sg(k,j?1)?≤si??sk?)min?{ f(k,j?1)+(si??sk?)2}

最后答案为 $\underset{1\le i\le n}{\min }f(n,i)$ 。

然后我们发现题目中对分成的段数并没有限制，于是去掉第二维，状态定义变成 $f(i)$ 为表示前 $i$ 个数分成若干段的最小答案。转移和上面那个差不多。

然而这种方法似乎精度很容易爆炸。。。我们必须换一种想法。

我们令 $b_i$ 等于一个合法的划分中每段 $a_i$ 的和。根据我们初中的数学知识可以得到，对于一个数列 $b$ 中的任意一个子区间 $[l,r]$，有：

$${\left(\sum _{i=l}^r{b}_i\right)}^2>\sum _{i=l}^r{b_i}^2$$

意思就是把一段长的区间分成尽可能多的短的区间之后，答案一定会变优。感性理解一下就是了。。。 这意味着我们的每次选的最后一个区间要尽可能地短。

然后我们记 $g(i)$ 为最后一个区间所选的右端点的位置，显然有：

g(i)=max?{j∣(j<i)∧(sj?sg(j)≤si?sj)}g(i) = \max \{ j | (j < i) \land (s_j - s_{g(j)} \le s_i - s_j)\} g(i)=max{ j∣(j<i)∧(sj??sg(j)?≤si??sj?)}

最后我们再沿着 $g(i)$ 倒回去算就可以了，当然也可以边转移边算。

然而这个转移是 $O(n^2)$ 的，无法通过这道题。我们考虑优化。

看到转移式子后面的那个不等式，我们将它变一下形就可以得到：

$$s_i\ge 2s_j?s_{g(j)}$$

不难 看出这个式子有单调性，于是用一个单调队列优化一下就是了。

然而我们并不能边转移边算了，因为这道题要用到 高精度 ，这样一做显然是要炸空间的。所以我们必须先处理出整个 $g(i)$ 再倒回去算。

总时间复杂度为 $O(n)$，另注意这道题卡空间，数组要想办法压掉几个。。。高精度也要做压位的。 不压位的我也不知道能不能过。。。

参考代码

其实这份代码的长度主要还是高精度。。。核心程序也就那么几行。。。

#include <cstdio>
#include <vector>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;typedef long long ll;
const int Maxn = 4e7;struct BigInteger {
    static const int BASE = 100000000;int num[15], len;BigInteger (ll x = 0) {
    *this = x;}inline void clear(BigInteger &x) {
    while(x.num[x.len] == 0 && x.len > 1)x.len--;}BigInteger operator = (ll rhs) {
    memset(num, 0, sizeof num);len = 0;do {
    num[++len] = rhs % BASE;rhs /= BASE;} while(rhs != 0);return *this;}BigInteger operator + (const BigInteger &rhs) {
    BigInteger ret;memset(ret.num, 0, sizeof ret.num), ret.len = 0;for(int i = 1, tmp = 0; tmp != 0 || i <= len || i <= rhs.len; i++) {
    tmp += num[i] + rhs.num[i];ret.num[++ret.len] = tmp % BASE;tmp /= BASE;}return ret;}BigInteger operator * (const BigInteger &rhs) {
    BigInteger ret;memset(ret.num, 0, sizeof ret.num), ret.len = len + rhs.len;for(int i = 1; i <= len; i++) {
    ll tmp = 0;for(int j = 1; j <= rhs.len || tmp != 0; j++) {
    tmp += 1LL * num[i] * rhs.num[j] + ret.num[i + j - 1];ret.num[i + j - 1] = tmp % BASE;tmp /= BASE;}}clear(ret);return ret;}BigInteger operator += (const BigInteger &rhs) {
    *this = *this + rhs;return *this;}BigInteger operator *= (const BigInteger &rhs) {
    *this = *this * rhs;return *this;}
};
ostream &operator << (ostream &out, const BigInteger &x) {
    out << x.num[x.len];for(int i = x.len - 1; i >= 1; i--) {
    char buf[20];sprintf(buf, "%08d", x.num[i]);out << buf;}return out;
}int N;
ll sum[Maxn + 5];ll B[Maxn + 5];
const ll mod = (1 << 30);inline void ReadIn() {
    int typ;scanf("%d %d", &N, &typ);if(typ == 0) {
    for(int i = 1; i <= N; i++)scanf("%lld", &sum[i]);} else {
    ll x, y, z;scanf("%lld %lld %lld %lld %lld", &x, &y, &z, &B[1], &B[2]);for(int i = 3; i <= N; i++)B[i] = ((x * B[i - 1] % mod) + (y * B[i - 2] % mod) + z) % mod;int m, las = 0, p;scanf("%d", &m);for(int i = 1; i <= m; i++) {
    int l, r;scanf("%d %d %d", &p, &l, &r);for(int j = las + 1; j <= p; j++)sum[j] = (B[j] % (r - l + 1)) + l;las = p;}}
}int f[Maxn + 5];
inline ll calc_val(int pos) {
    return sum[pos] * 2 - sum[f[pos]];
}int q[Maxn + 5], head, tail;int main() {
    
#ifdef LOACLfreopen("in.txt", "r", stdin);freopen("out.txt", "w", stdout);
#endifReadIn();for(int i = 1; i <= N; i++)sum[i] += sum[i - 1];head = tail = 1;for(int i = 1; i <= N; i++) {
    while(head < tail && calc_val(q[head + 1]) <= sum[i])head++;f[i] = q[head];while(head <= tail && calc_val(q[tail]) >= calc_val(i))tail--;q[++tail] = i;}BigInteger ans = 0;int p = N;while(p != 0) {
    BigInteger tmp(sum[p] - sum[f[p]]);ans += (tmp * tmp);p = f[p];}cout << ans;return 0;
}