题目
题目描述
2048 年，第三十届 CSP 认证的考场上，作为选手的小明打开了第一题。这个题的样例有 nn 组数据，数据从 1 \sim n1∼n 编号，ii 号数据的规模为 a_iai。
小明对该题设计出了一个暴力程序，对于一组规模为 uu 的数据，该程序的运行时间为 u^2u2。然而这个程序运行完一组规模为 uu 的数据之后，它将在任何一组规模小于 uu 的数据上运行错误。样例中的 a_iai 不一定递增，但小明又想在不修改程序的情况下正确运行样例，于是小明决定使用一种非常原始的解决方案：将所有数据划分成若干个数据段，段内数据编号连续，接着将同一段内的数据合并成新数据，其规模等于段内原数据的规模之和，小明将让新数据的规模能够递增。
也就是说，小明需要找到一些分界点 1 \leq k_1 \lt k_2 \lt \cdots \lt k_p \lt n1≤k1<k2<⋯<kp<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_ii=1∑k1ai≤i=k1+1∑k2ai≤⋯≤i=kp+1∑nai
注意 pp 可以为 00 且此时 k_0 = 0k0=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(i=1∑k1ai)2+(i=k1+1∑k2ai)2+⋯+(i=kp+1∑nai)2
小明觉得这个问题非常有趣，并向你请教：给定 nn 和 a_iai，请你求出最优划分方案下，小明的程序的最小运行时间。
输入格式
由于本题的数据范围较大，部分测试点的 a_iai 将在程序内生成。
第一行两个整数 n, typen,type。nn 的意义见题目描述，typetype 表示输入方式。
- 若 type = 0type=0，则该测试点的 a_iai 直接给出。输入文件接下来：第二行 nn 个以空格分隔的整数 a_iai，表示每组数据的规模。
- 若 type = 1type=1，则该测试点的 a_iai 将特殊生成，生成方式见后文。输入文件接下来：第二行六个以空格分隔的整数 x, y, z, b_1, b_2, mx,y,z,b1,b2,m。接下来 mm 行中，第 i (1 \leq i \leq m)i(1≤i≤m) 行包含三个以空格分隔的正整数 p_i, l_i, r_ipi,li,ri。
对于 type = 1type=1 的 23~25 号测试点，a_iai 的生成方式如下：
给定整数 x, y, z, b_1, b_2, mx,y,z,b1,b2,m，以及 mm 个三元组 (p_i, l_i, r_i)(pi,li,ri)。
保证 n \geq 2n≥2。若 n \gt 2n>2，则 \forall 3 \leq i \leq n, b_i = (x \times b_{i−1} + y \times b_{i−2} + z) \mod 2^{30}∀3≤i≤n,bi=(x×bi−1+y×bi−2+z)mod230。
保证 1 \leq p_i \leq n, p_m = n1≤pi≤n,pm=n。令 p_0 = 0p0=0，则 p_ipi 还满足 \forall 0 \leq i \lt m∀0≤i<m 有 p_i \lt p_{i+1}pi<pi+1。
对于所有 1 \leq j \leq m1≤j≤m，若下标值 i (1 \leq i \leq n)i(1≤i≤n)满足 p_{j−1} \lt i \leq p_jpj−1<i≤pj，则有
a_i = \left(b_i \mod \left( r_j − l_j + 1 \right) \right) + l_jai=(bimod(rj−lj+1))+lj
上述数据生成方式仅是为了减少输入量大小，标准算法不依赖于该生成方式。
输出格式
输出一行一个整数，表示答案。
输入输出样例
输入 #1复制
5 0 5 1 7 9 9
输出 #1复制
247
输入 #2复制
10 0 5 6 7 7 4 6 2 13 19 9
输出 #2复制
1256
输入 #3复制
10000000 1 123 456 789 12345 6789 3 2000000 123456789 987654321 7000000 234567891 876543219 10000000 456789123 567891234
输出 #3复制
4972194419293431240859891640
说明/提示
【样例 1 解释】
最优的划分方案为 \{5,1\}, \{7\}, \{9\}, \{9\}{5,1},{7},{9},{9}。由 5 + 1 \leq 7 \leq 9 \leq 95+1≤7≤9≤9 知该方案合法。
答案为 (5 + 1)^2 + 7^2 + 9^2 + 9^2 = 247(5+1)2+72+92+92=247。
虽然划分方案 \{5\}, \{1\}, \{7\}, \{9\}, \{9\}{5},{1},{7},{9},{9} 对应的运行时间比 247247 小，但它不是一组合法方案，因为 5 \gt 15>1。
虽然划分方案 \{5\}, \{1,7\}, \{9\}, \{9\}{5},{1,7},{9},{9} 合法，但该方案对应的运行时间为 251251，比 247247 大。
【样例 2 解释】
最优的划分方案为 \{5\}, \{6\}, \{7\}, \{7\}, \{4,6,2\}, \{13\}, \{19,9\}{5},{6},{7},{7},{4,6,2},{13},{19,9}。
题解
首先把a[]数组的定义搞清楚...
首先肯定是一道dp题，还要用高精（不想打）
如果用dp用一维的话：dp[i]转移就要记录它的前驱点g[i]
那么就可以实现n^2dp了
#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>
using namespace std;
#define LL long long
const int MAXN = 4e7+3;
const int MAXM = 1e5 + 3;
LL a[MAXN];
LL sum[MAXN] , dp[MAXN];
int que[MAXN] , tail , head;
int n ,type, g[MAXN];
LL b[MAXN] , x , y , z , m , p[MAXM] , x11[MAXM] , y11[MAXM];
int main()
{
scanf( "%d%d" , &n ,&type );
if( type == 0 ){
for( int i = 1 ; i <= n ; i ++ ){
scanf( "%lld" , &a[i] );
sum[i] = sum[i-1] + a[i];
}
}
else{
LL mod = 1;
for( int i = 1 ; i <= 30 ; i ++ )
mod *= 2;
scanf( "%lld%lld%lld%lld%lld%lld" , &x , &y , &z , &b[1] , &b[2] , &m );
for( int i = 3 ; i <= n ; i ++ ){
b[i] = ( b[i-1] * x % mod + b[i-2] * y % mod + z ) % mod;
}
p[0] = 0;
for( int i = 1 ; i <= m ; i ++ )
scanf( "%lld%lld%lld" , &p[i] , &x11[i] , &y11[i] );
for( int i = 1 ; i <= n ; i ++ ){
int len = lower_bound( p , p + m + 1 , i ) - p;
a[i] = ( b[i] % ( y11[len] - x11[len] + 1 ) ) + x11[len];
sum[i] = sum[i-1] + a[i];
}
}
memset( dp , 0x7f , sizeof( dp ) );
g[0] = 0 , dp[0] = 0;
for( int i = 1 ; i <= n ; i ++ ){
for( int j = i - 1 ; j >= 0 ; j -- ){
if( sum[i] - sum[j] >= sum[j] - sum[g[j]] )
if( dp[j] + ( sum[i] - sum[j] ) * ( sum[i] - sum[j] ) < dp[i] ){
dp[i] = dp[j] + ( sum[i] - sum[j] ) * ( sum[i] - sum[j] ) , g[i] = j;
}
}
}
printf( "%lld" , dp[n] );
return 0;
}64分就有了
最开始自己认为dp是两维，但是真的没有多想
然后就炸了...
但是如果用dp[i][j]表示最后一段结尾点是，起始点为j的最小权值
但是仔细想一想，其实对于dp[i]只有权值最小的dp[i][j]才会有贡献，所以就可以缩成一维
以上都是补充
————————————————————————————————————————————————————————
接下来是优化dp：通过一系列推理猜测可以发现g[]数组，也就是前驱数组是有单调性的。
对于一个转移，有sum[i] - sum[j] >= sum[j] - sum[g[j]]
所以: sum[i] >= 2 * sum[j] - sum[g[j]]
用单调队列优化
然后高精部分，就有int__128代替吧...
#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>
#define ll __int128
#define LL long long
#define reg register
const int mod = 1 << 30;
const int MAXN = 4e7 + 1;
const int MAXM = 1e5 + 1;
ll sum[MAXN];
LL b[4];
int que[MAXN] , tail , head;
int n ,type, g[MAXN];
int p[MAXM] , x11[MAXM] , y11[MAXM];
inline void write(ll x)
{
if(x>9) write(x/10);
putchar(x%10+'0');
}
inline void read( int &x ){
x = 0;
char s = getchar();
while( s < '0' || s > '9' )
s = getchar();
while( s >= '0' && s <= '9' )
x = x * 10 + s - '0' , s = getchar();
}
inline ll up( int i ){
return sum[i] * 2 - sum[g[i]];
}
int main()
{
read( n );read( type );
if( type == 0 ){
for( reg int i = 1 ; i <= n ; i ++ ){
read( type );
sum[i] = sum[i-1] +type;
}
}
else{
int x , y , z , m;
int e , r;
read( x );read( y );read( z );read( e );read( r );read( m );
b[1] = e;b[2] =r;
p[0] = 0;
for( reg int i = 1 ; i <= m ; i ++ )
read( p[i] ) , read( x11[i] ) , read( y11[i] );
int len = 1;
while( p[len] < 1 ) len ++;
sum[1] = ( b[1] % ( y11[len] - x11[len] + 1 ) ) + x11[len];
while( p[len] < 2 ) len ++;
sum[2] = sum[1] + ( b[2] % ( y11[len] - x11[len] + 1 ) ) + x11[len];
for( reg int i = 3 ; i <= n ; i ++ ){
while( p[len] < i ) len ++;
if( i % 3 == 1 ) e =0 , r = 2;
else if( i % 3 == 2 ) e = 1 , r = 0;
else
e = 2 , r = 1;
b[i%3] = ( b[e] * x % mod + b[r] * y % mod + z ) % mod;
type = ( b[i%3] % ( y11[len] - x11[len] + 1 ) ) + x11[len];
sum[i] = sum[i-1] + type;
}
}
g[0] = 0;
head = tail = 0;
que[head] = 0;
for( reg int i = 1 ; i <= n ; i ++ ){
while( head < tail && up( que[head+1] ) <= sum[i] )
head++;
g[i] = que[head];
while( head < tail && up( que[tail] ) >= up(i) )
tail--;
que[++tail] = i;
}
ll ans = 0;
for( reg int i = n ; i ; i = g[i]){
ans += ( sum[i] - sum[g[i]] ) * ( sum[i] - sum[g[i]] );
}
write(ans);
return 0;
}复习一下单调队列
队头的要比队尾的后进来，然后最小值要维护单调递增
