11.25 校内模拟赛总结

难评

复盘

7:40 开题

还是决定采取前期审题时间长一点的策略

T1，显然枚举斜率比较优，算一下复杂度是对的，就会了；T2 好神秘啊，感觉又是什么根据结论然后贪心删数；T3 显然是优化 dp，感觉可做；T4 嗯？这不是每日一题，按之前那个套路，把点分成一类点和二类点，直接放到线段树上维护合并就做完了？

感觉很稳啊，8:20 开码了

8:35 过了 T1 大样例，看 T2

手玩之后猜结论：贪心删能够被最早消完的。感觉很对，于是先写了指数暴力

然后写根据这个结论的做法，写完发现样例不过，一推发现假了

此时大概是 9:00，不急，写假做法的时候已经发现 $i, j$ 固定时 $s u m$ 是固定的，不关心前面的顺序，那么显然对于前面的部分可以 dp。继续想，只交换 $i$ 和 $i + 1$ ，影响应该比较小，那么拆成前缀和后缀，中间两个暴力合并，然而发现这样复杂度貌似还是三方，算了先写暴力，细节还挺多，写完就 9:40 了

写完后发现 dp 式子显然是格路，找到了一个十分简洁的转化：从 $(0, 0)$ 走到 $(n, n)$ ，每个格子上有权值，一条路径权值为经过的格点的权值的 $ma x + 1$

基于这一点合并就变得十分简单了，每次只会改一列，枚举中间点在哪即可做到 $n^2$ ，10:00 过了样例，然后开拍

接下来决定直接快速写完 T4，思路应该是比较清晰的

怒码 200 行，调了一小会，然后发现思路假了！我把限制转化成 $j\leq K+1-i$ ，然后就忽略了 $i < j$ 的限制；加上限制后每个点的合法决策是区间而不是前缀了，没法直接合并了

蚌，浪费 1h

只能完全换思路了，发现插数时好算贡献，删数时不好改贡献，那么上线段树分治，中间用线段树维护区间查 Max 就有 $n\log ^2$ 的做法， $5\times 10^5$ 说不定能过？

剩 1h 感觉不太写得完，还是看 T3

$n^4$ 很简单，然后想优化一维决策显然可以李超树做到 $n^3\log$ ，感觉太唐了吧！推点性质

发现转移时好像只用枚举颜色就行，分别找到 $a, b$ 中当前状态前面的第一个这种颜色转移就行，就 $n^3$ 了

先写，写着写着发现查每种颜色的 Max 显然可以拆成前缀和后缀用线段树直接维护，那就有 $n^2\log$ 了？不急，先写完

然后发现样例没过，再读题发现又读错了… … 他不能每次只迈左脚或者右脚，得一起迈

然后我的结论就直接假了，看时间已经 11:30 ，慌

思考了一下得到了一个差不多的结论：对于决策 $(p, q)$ ，如果后面还有相同的颜色对 $(p^{'}, q^{'})$ ，那么 $(p, q)$ 就是没用的

这显然说明了随着 $p$ 的增大， $q$ 是单调不增的，双指针就能做到 $n^3$

写了一会写破防了，发现细节很多，有一些边界问题

没办法，写 $n^4$ 吧，中间再加上一些玄学剪枝后能在 $1.2 s$ 内跑出 $n = 3000$ 的大样例，不过感觉没什么用

最后去写了 $T 4$ 的暴力，差点不会 $n^2$ 了，还好最后想到了单调队列…

然后就结束了

结果是：

$100 + 100 + 45 + 20 = 265$

( 怎么大家 T1 都挂了 a

T3 运气好得到了 45 pts

T4 的决策很失误啊！明明有线段树分治的稳定得分 60pts ，没写简直亏麻了

总结来说这场看错题的情况太多了啊！感觉快一半时间都在编假做法、写假做法… …

题解

T2

在这里插入图片描述
感觉挺妙的，记录一下

格路在很多题还是有奇效的

T3

在这里插入图片描述
~~感觉这种优化 dp 应该是挺擅长的点的，但是我不会~~

首先编一个好看的 $n^3$ 做法，注意到 转移时枚举的两个决策是十分独立的！！！ 我们考虑把决策分开来枚举，即：认为是先迈左脚，后迈右脚，加一维状态表示当前该迈哪只脚就能维护限制

就有转移：
在这里插入图片描述
拆开后显然是斜率优化板子，李超树 / 单调队列均可

诶

#include<bits/stdc++.h>
using namespace std ;typedef long long LL ;
const int N = 3010 ;
// 分步转移！！ int n , a[N] , b[N] ;
int f[N][N][2] ;
inline int D( int i , int j )
{return (j-i)*(j-i) ;
}
struct segment
{int K , B ;LL operator () ( int x ) { return K*x+B ; }
}tr[N*N*2] ;
struct Segtree
{int ls , rs ;
}t[N*N*2] ;
int rt[N][2] , tot ;
void Insert( int &p , int l , int r , segment L )
{if( !p ) {p = ++tot ; tr[p] = L ;return ;}int mid = (l+r)>>1 ;if( L(mid)<tr[p](mid) ) swap(L,tr[p]) ;if( L(l)<tr[p](l) ) Insert( t[p].ls , l , mid , L ) ;if( L(r)<tr[p](r) ) Insert( t[p].rs , mid+1 , r , L ) ;
}
int query( int p , int l , int r , int x )
{if( !p ) return 2e9 ;int mid = (l+r)>>1 , res = tr[p](x) ;if( x <= mid ) return min(res,query(t[p].ls,l,mid,x)) ;else return min(res,query(t[p].rs,mid+1,r,x)) ;
}int main()
{scanf("%d" , &n ) ;for(int i = 0 ; i <= n+1 ; i ++ ) {scanf("%d" , &a[i] ) ;}for(int i = 0 ; i <= n+1 ; i ++ ) {scanf("%d" , &b[i] ) ;}memset( f , 0x3f , sizeof f ) ;f[0][0][0] = 0 ;Insert(rt[0][0],0,n+1,{0,0}) ;for(int i = 0 ; i <= n+1 ; i ++ ) {for(int j = 0 ; j <= n+1 ; j ++ ) {if( i==0&&j==0 ) continue ;if( i ) f[i][j][1] = query(rt[j][0],0,n+1,i)+i*i ;if( a[i]==b[j] ) {if( j ) f[i][j][0] = query(rt[i][1],0,n+1,j)+j*j ;}if( f[i][j][0] < 1e9 ) Insert(rt[j][0],0,n+1,{-2*i,f[i][j][0]+i*i}) ;if( f[i][j][1] < 1e9 ) Insert(rt[i][1],0,n+1,{-2*j,f[i][j][1]+j*j}) ;}}printf("%d\n" , f[n+1][n+1][0] ) ;return 0 ;
}

T4

在这里插入图片描述
妙妙题

首先线段树分治显然可以 $n\log^2$

还有感觉很牛的 $n\sqrt n$ 做法：操作分块

把每 $B$ 次操作放在一起处理，称这 $B$ 次操作涉及到的位置为关键点

首先一遍单调队列处理出非关键点内部的答案；对于关键点与非关键点之间，只需要维护每个关键点左右 $k$ 个位置的最大值，单调队列维护即可；对于关键点之间，每次修改完后只对这 $B$ 个位置单独跑单调队列

算一下复杂度是 $n\sqrt n$ 的

~~感觉很高深，反正我想不到~~

然后说正解：

长度固定为 $K$ ，经典 trick 是每 $K$ 个分成一段

来看这样做有什么好处：首先段内贡献显然可以直接维护区间 $M a x, c M a x$

对于段间，假设两段中选的位置分别是 $i, j$ ，我们 注意力惊人 的发现： $i, j$ 中至少有一个是其所在段的最大值

简要证：不妨设 $a_i\leq a_j$ ，如果 $i, j$ 都不是最大值，考虑把 $i$ 换成 $j$ 所在段的最大值，答案显然会更优

这样答案的情况被大大简化了，只需要考虑某个最大值和相邻段进行匹配即可

具体来说：

首先最终的答案用堆维护，把所有可能的答案放到堆里，查询时弹堆顶

段内，直接线段树查 $M a x, c M a x$ ，扔堆里；修改时直接维护

段间，找到当前段的最大值，查前面段的一段后缀，后面段的一段前缀，扔堆里；
修改时，受影响的只有 $O (1)$ 个段内 $M a x$ 的匹配情况，暴力更新即可

#include<bits/stdc++.h>
using namespace std ;typedef long long LL ;
const int N = 5e5+10 , inf = 1e9+10 ;
// 每 K 个分一段，分别考虑段内与相邻段间贡献
// 注意力惊人的发现对于段间贡献，必选某一段中的最大值，修改时的复杂度就降低了 int n , K , m , a[N] , bl[N] ;
int ans[N][3] ;
struct node
{int v , x , id ;friend bool operator < ( node a , node b ) {return a.v<b.v ;}
};
priority_queue<node> q ;
struct Segtree
{int l , r , Mx , id , Cx ;
}t[N<<2] ;
inline void update( int p ) 
{if( t[p<<1].Mx >= t[p<<1|1].Mx ) {t[p].Mx = t[p<<1].Mx ; t[p].id = t[p<<1].id ;t[p].Cx = max( t[p<<1|1].Mx , t[p<<1].Cx ) ;}else {t[p].Mx = t[p<<1|1].Mx ; t[p].id = t[p<<1|1].id ;t[p].Cx = max( t[p<<1].Mx , t[p<<1|1].Cx ) ;}
}
void build( int p , int l , int r )
{t[p].l = l , t[p].r = r , t[p].Mx = t[p].Cx = -1e9 ;if( l == r ) {t[p].Mx = a[l] , t[p].id = l ;return ;}int mid = (l+r)>>1 ;build(p<<1,l,mid) ; build(p<<1|1,mid+1,r) ;update(p) ;
}
Segtree query( int p , int l , int r )
{if( l <= t[p].l && t[p].r <= r ) {return t[p] ;}int mid = (t[p].l+t[p].r)>>1 ;if( l>mid ) return query(p<<1|1,l,r) ;if( r <= mid ) return query(p<<1,l,r) ;Segtree R1 = query(p<<1,l,r) , R2 = query(p<<1|1,l,r) ;if( R1.Mx>=R2.Mx ) {return {0,0,R1.Mx,R1.id,max(R1.Cx,R2.Mx)} ;}else {return {0,0,R2.Mx,R2.id,max(R1.Mx,R2.Cx)} ;}
}
void modify( int p , int x , int d )
{if( t[p].l==t[p].r ) {t[p].Mx = d ;return ;}int mid = (t[p].l+t[p].r)>>1 ;if( x <= mid ) modify(p<<1,x,d) ;else modify(p<<1|1,x,d) ;update(p) ;
}
void Rebuild( int i , int f )
{ans[i][f] = -inf ;int l = (i-1)*K+1 , r = min(i*K,n) ;Segtree R = query(1,l,r) ;if( f == 2 ) {if( r+1 <= min(n,R.id+K-1) ) ans[i][f] = query(1,r+1,min(n,R.id+K-1)).Mx+R.Mx ;}else {if( max(1,R.id-K+1) <= l-1 ) ans[i][f] = query(1,max(1,R.id-K+1),l-1).Mx+R.Mx ;}if( ans[i][f]!=-inf ) q.push({ans[i][f],i,f}) ;
}int main()
{scanf("%d%d%d" , &n , &K , &m ) ;for(int i = 1 ; i <= n ; i ++ ) {scanf("%d" , &a[i] ) ;bl[i] = (i-1)/K+1 ;}build(1,1,n) ;for(int i = 1 ; i <= n ; i += K ) {int r = min(n,i+K-1) ;Segtree R = query(1,i,r) ;ans[bl[i]][1] = R.Mx+R.Cx ;q.push({ans[bl[i]][1],bl[i],1}) ;ans[bl[i]][0] = -inf ;if( bl[i]!=1 ) {if( max(1,R.id-K+1) <= i-1 ) ans[bl[i]][0] = query(1,max(1,R.id-K+1),i-1).Mx+R.Mx ;}if( ans[bl[i]][0] != -inf ) q.push({ans[bl[i]][0],bl[i],0}) ;ans[bl[i]][2] = -inf ;if( bl[i]!=bl[n] ) {if( r+1 <= min(n,R.id+K-1) ) ans[bl[i]][2] = query(1,r+1,min(n,R.id+K-1)).Mx+R.Mx ;}if( ans[bl[i]][2] != -inf ) q.push({ans[bl[i]][2],bl[i],2}) ;}printf("%d\n" , q.top().v ) ;int x , v ;while( m -- ) {scanf("%d%d" , &x , &v ) ;a[x] = v ;modify(1,x,v) ;int l = (bl[x]-1)*K+1 , r = min(bl[x]*K,n) ;Segtree R = query(1,l,r) ;if( ans[bl[x]][1] != R.Mx+R.Cx ) {ans[bl[x]][1] = R.Mx+R.Cx ;q.push({ans[bl[x]][1],bl[x],1}) ;}if( bl[x]!=1 ) {ans[bl[x]][0] = -inf ;if( max(1,R.id-K+1) <= l-1 ) ans[bl[x]][0] = query(1,max(1,R.id-K+1),l-1).Mx+R.Mx ;if( ans[bl[x]][0] != -inf ) q.push({ans[bl[x]][0],bl[x],0}) ;Rebuild(bl[x]-1,2) ;}if( bl[x]!=bl[n] ) {ans[bl[x]][2] = -inf ;if( r+1 <= min(n,R.id+K-1) ) ans[bl[x]][2] = query(1,r+1,min(n,R.id+K-1)).Mx+R.Mx ;if( ans[bl[x]][2] != -inf ) q.push({ans[bl[x]][2],bl[x],2}) ;Rebuild(bl[x]+1,0) ;}while( 1 ) {int x = q.top().x , id = q.top().id ;if( ans[x][id] != q.top().v ) q.pop() ;else {printf("%d\n" , ans[x][id] ) ; 	break ;}}}return 0 ;
}