划分

题目

题目描述

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∑k1​​ai​≤i=k1​+1∑k2​​ai​≤⋯≤i=kp​+1∑n​ai​

注意 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∑k1​​ai​)2+(i=k1​+1∑k2​​ai​)2+⋯+(i=kp​+1∑n​ai​)2

小明觉得这个问题非常有趣,并向你请教:给定 nn 和 a_iai​,请你求出最优划分方案下,小明的程序的最小运行时间。

输入格式

由于本题的数据范围较大,部分测试点的 a_iai​ 将在程序内生成。

第一行两个整数 n, typen,type。nn 的意义见题目描述,typetype 表示输入方式。

  1. 若 type = 0type=0,则该测试点的 a_iai​ 直接给出。输入文件接下来:第二行 nn 个以空格分隔的整数 a_iai​,表示每组数据的规模。
  2. 若 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​=(bi​mod(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;
}

复习一下单调队列

队头的要比队尾的后进来,然后最小值要维护单调递增

 

©️2020 CSDN 皮肤主题: 大白 设计师:CSDN官方博客 返回首页