2026gdsy秋季集训 (9月)
9.3
T1
树形dp哈哈。
首先考虑如何刻画方案数,发现这个可以算在每个点上,对于每个点选择不同的边构成的序列是一一对应的,所以考虑计数每个点在哪条边取到的方案数。设状态\(f_{u,0/1/2}\)分别表示考虑u子树内,u在做到u的父边之前就已经染色/在做父边的时候染色/在做父边后仍未被染色的方案数。首先枚举每个给u染色的出边来转移0/2,
2还有一种情况就是不染色,那么就是
然后1的情况就是
这个显然可以用前后缀积优化维护。
T2
分成两问解决。
opt1
首先如果x在区间外面直接输出就行,然后分类讨论x有可能是前k大,那么肯定就是在最右边,如果x的左边比它大的个数小于等于k,那么每次肯定会被往左推k步,如果都不满足,那么可以通过有一个结论,做k步之后一定会变成原来第k个1的位置-k,这些都可以对建序列主席树对值域可持久化维护出现次数就行了。
opt2
排序后的前i位是原来数组前i+k位的前i小,那么第i位肯定是小于等于第i小的,我们发现它只有两种取值,第一种是第i小,第二种是原来数组的a[i+k],首先a它肯定不能大于第i小,而且不能大于a[i+k],如果大于a[i+k]也会被换掉,而且它一定可以取到最值。
Code
#include<bits/stdc++.h>
#define lm ((l+r)>>1)
#define rm (lm+1)
using namespace std;
const int N=6e5+5,M=N*23;
int n,q,o,tot,a[N],b[N],c[M],rt[M],ls[M],rs[M];
void build(int &k,int l,int r){k=++tot;if(l==r)return;build(ls[k],l,lm),build(rs[k],rm,r);}
void update(int &k,int l,int r,int x){
if(l>x||r<x)return;
++tot,ls[tot]=ls[k],rs[tot]=rs[k],c[tot]=c[k]+1,k=tot;
if(l==r)return;
update(ls[k],l,lm,x),update(rs[k],rm,r,x);
}
int calc(int k,int l,int r,int s,int t){
if(l>t||r<s)return 0;
if(l>=s&&r<=t)return c[k];
return calc(ls[k],l,lm,s,t)+calc(rs[k],rm,r,s,t);
}
int find(int k,int l,int r,int x){
if(l==r)return l;
int y=c[ls[k]];
if(y>=x)return find(ls[k],l,lm,x);
return find(rs[k],rm,r,x-y);
}
int query(int u,int v,int l,int r,int x){
if(l==r)return l;
int y=c[ls[v]]-c[ls[u]];
if(y>=x)return query(ls[u],ls[v],l,lm,x);
return query(rs[u],rs[v],rm,r,x-y);
}
int main(){
freopen("sort.in","r",stdin);
freopen("sort.out","w",stdout);
ios::sync_with_stdio(0),cin.tie(0);
cin>>n>>q>>o;
for(int i=1;i<=n;i++)cin>>a[i],b[a[i]]=i;
build(o==1?rt[n+1]:rt[0],1,n);
if(o==1)for(int i=n;i;i--)update(rt[i]=rt[i+1],1,n,b[i]);
else for(int i=1;i<=n;i++)update(rt[i]=rt[i-1],1,n,a[i]);
while(q--){
int l,r,k,x;
cin>>l>>r>>k>>x;
if(o==1){
if(b[x]<l||b[x]>r)cout<<b[x];
else{
int y=calc(rt[x],1,n,l,r);
if(y<=k)cout<<r-y+1;
else if(calc(rt[x],1,n,l,b[x])>k)cout<<b[x]-k;
else cout<<find(rt[x],1,n,calc(rt[x],1,n,1,l-1)+k+1)-k;
}
}
else{
if(x<l||x>r)cout<<a[x];
else{
int y=query(rt[l-1],rt[min(r,x+k-1)],1,n,x-l+1);
if(x+k<=r)y=min(y,a[x+k]);
cout<<y;
}
}
cout<<'\n';
}
}
T3
首先大于和小于没区别,所以就变成(1-等于)/2,然后两个集合的和相等有一个trick,可以把另一个集合变成负数然后和为零。显然负数不好做,直接右边全部加m,把值域统一,改到[0,m],所以说就变成了2n值域在[0,m]的数的和是nm。考虑这个上界的限制还是不好做,所以直接考虑把上界容斥掉,直接枚举超过m的个数,然后钦定每个数减掉m+1,剩下的插板法就行了,式子就是\(\sum_{i=0}^{nm/(m+1)}(-1)^i\binom{2n}{i}\binom{nm-i(m+1)+2n-1}{2n-1}\),时间复杂度\(O(nm+tn)\)。
T4
考虑查询的节点会被什么贡献,首先肯定在这个节点最后一次下传之后才会有贡献,然后最后一次下传到该节点一定是最后一次刚好改到该节点,在这个区间内的所有修改都有贡献,那么答案就是这两个时间内与询问节点有交的所有修改的和,再变成f(r)-f(l),询问就变成了每次问前i个修改操作对于某个区间的贡献,我们发现对于所有包含当前节点的的区间,我们询问这个区间的任何一个点都是对的,然后对于相交的,最后肯定能减掉,所以说离线下来扫描线就行。问题就变成了如何去找到每个点最晚的被下传的时间,注意到一个节点标记被下传的条件是修改区间与这个节点有交且不包含这个节点,有两种情况,修改区间的端点在节点内部(不含端点),修改区间的左/右端点是节点右/左端点,那么修改的时候单点改然后查询区间取max就行了。
Code
#include<bits/stdc++.h>
#define ls (k<<1)
#define rs (ls|1)
#define lm ((l+r)>>1)
#define rm (lm+1)
#define pb push_back
using namespace std;
const int N=2e5+5;
int n,m,tot,a[N],L[2*N],R[2*N],fa[2*N],tl[N],tr[N],mx[4*N],t[N],ans[N];
vector< pair<int,int> > g[N],h[N];
struct node{int o,l,r,x;}q[N];
void build(int k,int l,int r){
tot++,fa[tot]=k,k=tot,L[k]=l,R[k]=r;
if(l<r){
int m;cin>>m;
build(k,l,m),build(k,m+1,r);
}
h[l].pb({r,k});
}
void update(int k,int l,int r,int x,int y){
if(l>x||r<x)return;
mx[k]=y;
if(l==r)return;
update(ls,l,lm,x,y),update(rs,rm,r,x,y);
}
int query(int k,int l,int r,int s,int t){
if(l>t||r<s)return 0;
if(l>=s&&r<=t)return mx[k];
return max(query(ls,l,lm,s,t),query(rs,rm,r,s,t));
}
int calc(int l,int r){return max({query(1,1,n,l+1,r-1),tl[r],tr[l]});}
void add(int x,int y){for(int i=x;i<=n;i+=i&-i)t[i]+=y;}
int ask(int x){int y=0;for(int i=x;i;i-=i&-i)y+=t[i];return y;}
int main(){
freopen("oracle.in","r",stdin);
freopen("oracle.out","w",stdout);
ios::sync_with_stdio(0),cin.tie(0);
cin>>n>>m;
for(int i=1;i<=n;i++)cin>>a[i];
build(0,1,n);
for(int i=1;i<=m;i++){
cin>>q[i].o>>q[i].l>>q[i].r;
if(q[i].o==2)cin>>q[i].x;
}
for(int i=1;i<=m;i++){
int l=q[i].l,r=q[i].r;
if(q[i].o==1){
int k=lower_bound(h[l].begin(),h[l].end(),make_pair(r,0))->second;
g[fa[k]?calc(L[fa[k]],R[fa[k]]):i].pb({i,1});
if(l<r)g[calc(l,r)].pb({i,-1});
else ans[i]+=a[l];
}
else update(1,1,n,l,i),update(1,1,n,r,i),tl[l]=tr[r]=i;
}
for(int i=1;i<=m;i++){
if(q[i].o==2)add(q[i].l,q[i].x),add(q[i].r+1,-q[i].x);
for(auto [x,o]:g[i])ans[x]+=o*ask(q[x].l);
}
for(int i=1;i<=m;i++)if(q[i].o==1)cout<<ans[i]<<'\n';
}
9.5
T1
反悔贪心。题目可以转化为每次选两个不交的区间匹配,问最大匹配数。对所有按照左端点从小到大排序,如果当前线段未被匹配,那么就给当前区间找到左端点最小的未被匹配的合法线段进行匹配;如果当前线段已被匹配,那么需找到一个左端点最小的线段替代当前线段进行匹配,然后再给当前线段找匹配线段。这两种操作做完之后答案都能加一,可以证明这是对的。
Code
#include<bits/stdc++.h>
using namespace std;
const int N=3e5+5;
int n,m,mch[N],ans[N];
struct node{int l,r,i,j;}a[N];
bool operator <(node x,node y){return x.l!=y.l?x.l<y.l:(x.r!=y.r?x.r<y.r:x.i<y.i);}
bool cmp(node x,node y){return x.r!=y.r?x.r<y.r:x.l<y.l;}
set<node> s;
int main(){
freopen("project.in","r",stdin);
freopen("project.out","w",stdout);
ios::sync_with_stdio(0),cin.tie(0);
cin>>n>>m;
for(int i=1;i<=n;i++)cin>>a[i].l>>a[i].r,a[i].i=i;
sort(a+1,a+n+1);
for(int i=1;i<=n;i++)a[i].j=i,s.insert(a[i]);
for(int i=1;i<=n&&m;i++){
bool f=1;
if(!mch[i]){
auto j=s.lower_bound({a[i].r+1,0});
if(j==s.end())f=0;
else ans[a[i].i]=ans[j->i]=m--,mch[j->j]=i,s.erase(j),s.erase(a[i]);
}
else{
int j=mch[i];
auto x=s.lower_bound({a[i].r+1,0});
if(x==s.end())f=0;
else{
node tmp=*x;s.erase(x);
x=s.lower_bound({a[j].r+1,0});
if(x==s.end())f=0,s.insert(tmp),s.insert(a[i]);
else ans[x->i]=ans[a[j].i],ans[a[i].i]=ans[tmp.i]=m--,mch[tmp.j]=i,mch[x->j]=j,s.erase(x);
}
}
}
for(auto i=s.begin();i!=s.end()&&m;i++)ans[i->i]=m--;
for(int i=1;i<=n;i++)cout<<ans[i]<<' ';
}
T2
首先答案肯定是一条从上到下的链,然后往左右各有一个分叉。
然后这个东西可以先预处理处每个点到四个方向的距离,然后最后一次从上方跑最短路多两维0/1记录一下当前是否往左往右分叉过,然后如果用优先队列跑有可能常数过大,注意到最后答案一定小于\(W(n+m)\),所以说直接改为对于每个dis开vector维护然后用一个变量维护当前下标就行了。
T4
(约定被取下的是白点,没被取下的是黑点)
借鉴wjr的BIT做法,但他说做法的容易推广有点抽象,我以一种更好理解的方法说明(通过构造函数来维护修改tag),这样实现的细节比较好处理。首先我们需要求一个点最近的白色祖先。考虑树剖在每一个重链维护一个set。查询时在每一个重链上跳,如果找到一个合法的重链就在这个重链找前驱就行了,由于只有找一次前驱并且一共只会跳log次重链,所以复杂度是\(O(\log n)\)的。然后第一问是动态删/加点,然后维护连通块大小。然后可以构造函数\(f_u\)表示以u为根的联通块大小(白点包含在儿子的连通块),那么删/加点操作就是当前点到上一个白点的链上全部减/加当前连通块大小。然后对于第二问,还是动态删/加点,不过多了连通块加。连通块加是因为我们可以维护每个点答案的绝对值,因为每次操作所有点的绝对值变化是相同的,这样只需要最后答案统计的时候加上符号就行了。我们还是一样通过构造函数维护,函数\(g_x\)表示x的真实值减去父亲的真实值,如果当前点是白点,被减数就为0。然后这样删/加点就相当于加/减当前点父亲的真实值,然后连通块加就是顶点加,最后求答案的时候把所有点改成黑点就行了,这些直接用树剖做是\(O(q\log^2 n)\)的,但是根据经典结论,链操作可以差分成根链操作,根链操作可以对偶成子树操作,子树操作直接在dfs序上做就行了,由于是单点查/改,所以可以用树状数组维护做到\(O(q\log n)\),瓶颈在set。
#include<bits/stdc++.h>
#define pb push_back
using namespace std;
const int N=1e5+5,p=360;
int n,q,tot,h[N],sz[N],fa[N],top[N],dep[N],dfn[N],mp[N];
bool a[N];
vector<int> g[N];
set<int> s[N];
struct BIT{
int t[N];
void add(int x,int y){if(x)for(;x<=n;x+=x&-x)t[x]+=y;}
int ask(int x){int y=0;for(;x;x-=x&-x)y+=t[x];return y;}
void add1(int x,int y){add(dfn[x],y);}
void add2(int x,int y){add1(x,y),add(dfn[x]+sz[x],-y);}
void add3(int x,int z,int y){add1(x,y),add1(fa[z],-y);}
int ask1(int x){return ask(dfn[x]);}
int ask2(int x){return ask(dfn[x]+sz[x]-1)-ask(dfn[x]-1);}
int ask3(int x,int z){return ask1(x)-ask1(fa[z]);}
}T1,T2;
int C(int u){return dep[u]&1?-1:1;}
void dfs1(int u,int f){
sz[u]=1,fa[u]=f,dep[u]=dep[f]+1;
for(int v:g[u])if(v!=f){
dfs1(v,u),sz[u]+=sz[v];
if(sz[v]>sz[h[u]])h[u]=v;
}
}
void dfs2(int u,int f){
dfn[u]=++tot,mp[tot]=u,top[u]=f;
if(h[u])dfs2(h[u],f);
for(int v:g[u])if(v!=fa[u]&&v!=h[u])dfs2(v,v);
}
int find(int u){
int v=h[u];
while(u){
int x=top[u];
if(!s[x].empty()&&*s[x].begin()<=dfn[u]){
auto i=--s[x].upper_bound(dfn[u]);
if(*i==dfn[u])return v;
return h[mp[*i]];
}
v=top[u],u=fa[v];
}
return 1;
}
void op1(int x){
int z=fa[find(x)];
T1.add3(fa[x],z,-T1.ask2(x)),a[x]=1,T2.add2(x,T2.ask3(fa[x],z));
s[top[x]].insert(dfn[x]);
}
void op2(int x){
int z=fa[find(fa[x])];
T1.add3(fa[x],z,T1.ask2(x)),a[x]=0,T2.add2(x,-T2.ask3(fa[x],z));
s[top[x]].erase(dfn[x]);
}
int main(){
ios::sync_with_stdio(0),cin.tie(0);
cin>>n;
for(int i=1;i<n;i++){
int u,v;
cin>>u>>v;
g[u].pb(v),g[v].pb(u);
}
dfs1(1,0),dfs2(1,1);
for(int i=1;i<=n;i++)T1.add3(i,i,sz[i]);
cin>>q;
while(q--){
int o,x,y;
cin>>o>>x;
if(o==1)op1(x);
if(o==2)op2(x);
if(o==3){
cin>>y;int z=find(x);
cout<<T1.ask2(z)*y<<'\n',T2.add2(z,C(x)*y);
}
}
for(int i=1;i<=n;i++)if(a[i])op2(i);
int ans=0;
for(int i=1;i<=n;i++)ans+=(C(i)*T2.ask3(i,1)%p+p)%p;
cout<<ans;
}
9.15
T1
首先考虑答案是什么,就是\(\max h*\sum w\),其中h和w可以互换,这个max显然不太好做,那么就先扫描线从小到大枚举max,这样对于两边都小于等于max的肯定竖着放,对于有一边大于max的只能横着放,然后两边都大于的显然不能发,那么每个数的状态都是确定的,这样用一个multiset维护最小的k个数就行了,扫描线移动的过程就相当于把长边删掉,把小边加入,可能要注意h等于w的情况。
赛时问题
赛时开始看错题了,以为全部都要选,然后恰好k个翻转,实际上这个跟这题差不多,但是浪费了比较多时间
Code
#include<bits/stdc++.h>
#define int long long
#define pb push_back
using namespace std;
const int N=1e6+5;
int n,k,sum,w[N],h[N];
vector<int> g[N];
multiset< int,greater<int> > s;
void ins(int x){
if(s.size()<k)sum+=x,s.insert(x);
else if(s.size()==k&&x<*s.begin())sum+=x-*s.begin(),s.erase(s.begin()),s.insert(x);
}
signed main(){
freopen("canopy.in","r",stdin);
freopen("canopy.out","w",stdout);
ios::sync_with_stdio(0),cin.tie(0);
cin>>n>>k;
for(int i=1;i<=n;i++){
cin>>w[i]>>h[i],g[w[i]].pb(i);
if(w[i]!=h[i])g[h[i]].pb(i);
}
int ans=1e18;
for(int i=1;i<=1e6;i++)if(!g[i].empty()){
for(int x:g[i]){
if(w[x]>i)ins(w[x]);
else if(h[x]>i)ins(h[x]);
else{
if(w[x]!=h[x]){
auto it=s.find(max(w[x],h[x]));
if(it!=s.end())sum-=*it,s.erase(it);
}
ins(min(w[x],h[x]));
}
}
if(s.size()==k)ans=min(ans,i*sum);
}
cout<<ans;
}
T2
发现同余是不好做的,考虑能否转化为相等,这样就可以使用字符串哈希了,显然可以先给每个a_i模p(我去赛时没想到),这样最后\(a_i+a_j+a_k\)只有\(0,p,2p\)三种取值就做完了。然后先枚举\(a_i和a_j\),但是高精度加法显然超时了,注意到哈希具有可加性,直接哈希值相加就行了,然后\(a_k\)可以用unordered_map找。然后高精取模是简单的,因为99999很特殊,从高到低位\(a_{i-l} \gets a_i\)就是对的了。
T3
首先根据期望的线性性,总的期望等于每一个格子的期望。显然先离散化,设c_i表示第i个墙的最终高度,第i列第x行的答案就是\(P[c_i<x](1-\prod_{j<i}P[c_j<x])(1-\prod_{j>i}P[c_j<x])\),把括号拆了,就变成\(P[c_i<x]-\prod_{j\le i}P[c_j<x]-\prod_{j\ge i}P[c_j<x]+\prod_{j}P[c_j<x]\),显然如果这个式子直接维护就是\(O(n^2)\)的,考虑优化。从下到上扫描线,每一次维护当前行的答案,扫描线移动的时候,会有若干个i的\(P[c_j<x]\)会加上1/2,我们考虑对于上述的4个项分别维护。首先第一项和第四项是好维护的,第二三项实际上就是一个区间覆盖或者后/前缀乘2,然后全局求和,这取决于你当前的\(P[c_j<x]\)是0还是1/2,这个如果用线段树暴力维护tag是可以做的,不过可能实现细节比较多,时间复杂度\(O(n\log n)\)。显然这很不优雅,注意到我们最后本质上答案等价于极大的非0前后缀的答案,那我们可以把零全部改成一,这样区间赋值就改成了后缀乘1/2,用一个指针来维护当前极大的非0前后缀在哪就行了,在仙人掌上常数较大,需要用标记永久化化卡常,记得离散化求答案要乘上。
赛时记录
由于之前见过n次这道题,而且我个人一直以为非常困难,所以赛时一直不敢开这题,然后发现是比较好做的,但是已经时间不够了,而且我没有想到后面的优化,暴力维护tag细节太多了,所以赛时没有调过。
Code
#include<bits/stdc++.h>
#define int long long
#define pb push_back
#define ls (k<<1)
#define rs (ls|1)
#define lm ((l+r)>>1)
#define rm (lm+1)
using namespace std;
const int N=5e5+5,M=N*4,p=1e9+7,inv=5e8+4;
int n,m,a[N],b[N],c[N*2];
bool vis[N];
vector<int> g[N*2];
struct SGT{
int sum[M],tag[M];
void pushup(int k){sum[k]=(sum[ls]+sum[rs])%p*tag[k]%p;}
void build(int k=1,int l=1,int r=n){
tag[k]=1;
if(l==r){sum[k]=1;return;}
build(ls,l,lm),build(rs,rm,r);
pushup(k);
}
void modify(int s,int t,int x,int k=1,int l=1,int r=n){
if(l>t||r<s)return;
if(l>=s&&r<=t){sum[k]=sum[k]*x%p,tag[k]=tag[k]*x%p;return;}
modify(s,t,x,ls,l,lm),modify(s,t,x,rs,rm,r);
pushup(k);
}
int query(int s,int t,int x=1,int k=1,int l=1,int r=n){
if(l>t||r<s)return 0;
if(l>=s&&r<=t)return sum[k]*x%p;
x=x*tag[k]%p;
return (query(s,t,x,ls,l,lm)+query(s,t,x,rs,rm,r))%p;
}
}A,B;
signed main(){
freopen("barrel.in","r",stdin);
freopen("barrel.out","w",stdout);
ios::sync_with_stdio(0),cin.tie(0);
cin>>n;
for(int i=1;i<=n;i++)cin>>a[i],c[++m]=a[i];
for(int i=1;i<=n;i++)cin>>b[i],c[++m]=b[i];
sort(c+1,c+m+1),m=unique(c+1,c+m+1)-c-1;
for(int i=1;i<=n;i++)g[lower_bound(c+1,c+m+1,a[i])-c].pb(i),g[lower_bound(c+1,c+m+1,b[i])-c].pb(i);
int ans=0,sum=0,L=1,R=n;
A.build(),B.build();
for(int i=1;i<m;i++){
sum+=g[i].size();
for(int x:g[i]){
if(!vis[x])vis[x]=1,A.modify(x,n,inv),B.modify(1,x,inv);
else A.modify(x,n,2),B.modify(1,x,2);
}
while(vis[L])L++;
while(vis[R])R--;
ans=(ans+((sum*inv%p-A.query(1,L-1)-B.query(R+1,n)+!R*A.query(n,n)*n%p)%p+p)%p*(c[i+1]-c[i])%p)%p;
}
for(int i=1;i<=n;i++)ans=ans*2%p;
cout<<ans;
}
T4
匹配问题考虑建图hall定理。\(a_i\)连向\(b_i\),\(b_i\)向所有满足条件的\(a_j\)。这样子如果我们找到了一个完美匹配,再加上\(a_i\)连上\(b_i\)的边,就有一个对应的环分解。那么根据hall定理,考虑构造一个反例\(|N(S)|<|S|\),那么\(|N(S)|\)显然只跟最小的b有关系,所以说\(|N(S)|=\sum_i[b_{min}<a_i]-1\),因为我们不考虑\(a_{min}\)和\(b_{min}\)的边,并且一定不会有\(b_i\)能到\(a_{min}\),因为如果有这种b一定会把限制放宽。那么枚举这个\(b_{min}\),那么对一个固定的\(|N(S)|\),显然\(S\)越大越好,那么\(S\)就是所有\(b_i>b_{min}\)的b。那么最后合法的条件就是\(\forall i,1+\sum_j[a_i<b_j] \le \sum_j[b_i<a_j]-1\),移项变成\(2 \le \sum_j[b_i<a_j]-\sum_j[a_i<b_j]\),惊奇的发现就是右边就是相交的区间个数,所以原题的充要条件就变成每个\([a_i,b_i]\)区间都有相交的区间。考虑怎么快速维护这个东西,设\(L/R_i\)为i左/右边第一个和它相交的区间,这个东西可以在值域上扫描线区间覆盖区间求max做。然后对于每个询问,就变成了l到r必须包含\(L_i\)和\(R_i\)的其中一个。考虑对下标扫描线,在线段树上维护还有哪些i的\(R_i\)未被包含的\(L_i\)的最小值,然后修改就是单点删除和区间求最小值,然后就做完了,时间复杂度\(O(n\log n)\)
Code
#include<bits/stdc++.h>
#define ls (k<<1)
#define rs (ls|1)
#define lm ((l+r)>>1)
#define rm (lm+1)
using namespace std;
const int N=5e5+5,M=N*8;
int n,m,q,a[N],b[N],L[N],l[N],r[N],ans[N];
basic_string<int> g[N],h[N];
namespace SGT{
int mx[M],tag[M];
void adt(int k,int x){mx[k]=tag[k]=x;}
void pushup(int k){mx[k]=max(mx[ls],mx[rs]);}
void pushdw(int k){int &x=tag[k];if(x)adt(ls,x),adt(rs,x),x=0;}
void build(int k,int l,int r){
tag[k]=0;
if(l==r){mx[k]=n-L[l];return;}
build(ls,l,lm),build(rs,rm,r);
pushup(k);
}
void modify(int k,int l,int r,int s,int t,int x){
if(l>t||r<s)return;
if(l>=s&&r<=t){adt(k,x);return;}
pushdw(k);
modify(ls,l,lm,s,t,x),modify(rs,rm,r,s,t,x);
pushup(k);
}
int query(int k,int l,int r,int s,int t){
if(l>t||r<s)return 0;
if(l>=s&&r<=t)return mx[k];
pushdw(k);
return max(query(ls,l,lm,s,t),query(rs,rm,r,s,t));
}
}
using namespace SGT;
int main(){
freopen("duel.in","r",stdin);
freopen("duel.out","w",stdout);
ios::sync_with_stdio(0),cin.tie(0);
cin>>n,m=2*n;
for(int i=1;i<=n;i++)cin>>a[i];
for(int i=1;i<=n;i++)cin>>b[i];
for(int i=1;i<=n;i++)L[i]=query(1,1,m,b[i],a[i]),modify(1,1,m,b[i],a[i],i);
memset(mx,0,sizeof(mx)),memset(tag,0,sizeof(tag));
for(int i=n;i>=1;i--)g[n+1-query(1,1,m,b[i],a[i])]+=i,modify(1,1,m,b[i],a[i],n+1-i);
build(1,1,n);
cin>>q;
for(int i=1;i<=q;i++)cin>>l[i]>>r[i],h[r[i]]+=i;
for(int i=1;i<=n;i++){
for(int x:g[i])modify(1,1,n,x,x,0);
for(int x:h[i])ans[x]=n-query(1,1,n,l[x],i)>=l[x];
}
for(int i=1;i<=q;i++)cout<<(ans[i]?"Yes":"No")<<'\n';
}
9.20
T1
这个操作过于麻烦了,所以说想着怎么简化这个操作。发现这个交换很麻烦,考虑转换成两个数交换,手玩一下就会发现下面这个图。
这样我们就通过3次操作将a,b交换了。然后我们发现做一次1,再做一次n,序列不变,所以说只用考虑a,b操作次数的奇偶性。如果n和m至少有一个奇数,那么我们就可以对奇数的数组做n次1,这样数组还是不会变,然后奇偶性就对了。最后如果全是偶数一定无解,考虑奇偶性。
T2
由于操作可逆,考虑中转。转化成一个排列做n次到0~n-1,注意到贪心交换的最坏情况已经是n次了,所以大胆猜测每次一定能换一个。所以说我们假设归位x,那么设\(p_y=x\),那么原式就转化为了\(p_x \oplus x \le p_y \oplus y\),那么用堆维护最小的x就做完了。
T3
首先颜色数<=k非常好做,因为只会操作1*1,然后>k的猜测操作数很少,实际上最多两次。考虑构造,首先第一步我们钦定是删左上角,且能删越多越好(钦定删掉的部分的颜色跟其他部分相同),然后再从上一个正方形的右下角往左上角删,这样第一次可以删1个,后面都能删两个,但是可能奇偶性不对,注意到两个正方形的颜色可以不同,所以就做完了。
那么只用判定是否一次能删光,那么就是原正方形挖掉一个正方形后的颜色数要为k或k-1,首先枚举长度,然后判断以(i,j)为左上角的正方形能删掉多少个,考虑每一个颜色的贡献,这个正方形一定可以覆盖到所有的这个颜色,对应的(i,j)的范围可以算出来,所以预处理是矩形覆盖,查询是单点查,直接二位差分就行了,时间复杂度\(O(n^3)\)。
T4
注意到值域很奇怪,不妨转化为 \(1\le i-a_i \le n\),考虑图论建模,将\(i\)连上\(i-a_i\),这显然是一棵外向基环树,然后发现取这个环就是对的,因为\(a_i=i-nxt_i\),最后一定会消掉。
T5
考虑逆序对,合法的一个必要条件就是\(\frac{n(n-1)}{2} \equiv 0\pmod 2\),即\(n\equiv 0,1 \pmod 2\),通过构造证明它是充分的。考虑增量构造,那我们可以先做完n-4,然后考虑[1,n-4]与[n-3,n]的贡献,首先我们可以一直操作(n-3,i),将1到n-3向右循环位移,变成n-3,1,2......n-4,n-2,n-1,n,然后将1到n-2向左循环位移,就变成1,2,.....,n-4,n-2,n-3,n-1,n,将n-2和n-3交换了,然后对n-1和n也一样做,最后就变成1,2,...,n-4,n-2,n-3,n,n-1,然后做(n-3,n),(n-2,n-1),(n-3,n-1),(n-2,n)就还回去了。
Code
#include<bits/stdc++.h>
using namespace std;
int n;
void out(int x,int y){cout<<x<<' '<<y<<'\n';}
void upd(int x){
for(int i=1;i<=n-4;i++)out(i,x-1);
out(x-1,x);
for(int i=n-4;i>=1;i--)out(i,x);
}
signed main(){
ios::sync_with_stdio(0),cin.tie(0);
cin>>n;
if(n%4>1)cout<<"NO";
else{
cout<<"YES\n";
for(;n>1;n-=4)upd(n-2),upd(n),out(n-3,n),out(n-2,n-1),out(n-3,n-1),out(n-2,n);
}
}
9.23
T1
首先肯定取b取满k是最优的,那就相当于你每次会给一个质数的质数加一,然后每个质数能加的次数是固定的,然后因数个数这个东西是\(\prod {c_i+1}\) 的,那么如果外面再套一个乘积,显然对于每个质数都是独立的,那我们就对每个质数考虑,显然每次加肯定给c最少的数加,直接用堆维护就行了,大概是\(O(n \log^2 n)\)的?不会分析。
T2
这种类型的题目,有一个一般的套路,就是考虑每一次进位来dp,因为进位一次肯定最后面就会多一段0出来,然后这一次进位比上一次进位的0的数量肯定多1,我们设 \(f/g_{i,j,k}\)表示当前从低到高,第2到i为都是0,然后最高位到i+1位的最大值是j,个位是k,跳到进位到i+1时个位是多少/跳了几次,然后这个东西可以直接预处理,那么就剩下取模的问题了。首先呢,我们每次跳的时候跳到<m,次数<=n的最大值,这个可以从高到低枚举进位到哪一位(类似倍增处理)。然后再跳一次肯定要对m取模了,我们肯定不能一直循环做,因为模数很小的时候就会做很多次。注意到每一次最多加9,所以说最后对m取模后的值一定小于等于9,所以对于每一个个位,可以直接记忆化周期长度就做完了。
#include<bits/stdc++.h>
#define int long long
using namespace std;
const int N=25,inf=2e18;
int A,m,n,w[N],P[N],f[N][N][N],g[N][N][N];
int W(int x){int y=0;while(x)y=max(y,x%10),x/=10;return y;}
signed main(){
freopen("gentleman.in","r",stdin);
freopen("gentleman.out","w",stdout);
ios::sync_with_stdio(0),cin.tie(0);
w[0]=1;
for(int i=1;i<=18;i++)w[i]=w[i-1]*10;
for(int i=1;i<=18;i++)for(int j=0;j<10;j++)for(int k=0;k<10;k++){
int &F=f[i][j][k],&G=g[i][j][k];
F=k;
if(!j&&!k)G=inf;
else if(i==1){
while(F<10)F+=max(j,F),G++;
F-=10;
}
else for(int l=0;l<10;l++)G+=g[i-1][max(j,l)][F],F=f[i-1][max(j,l)][F];
}
cin>>A>>m>>n,n--;
while(A&&n){
int p;
do{
p=0;int x=A/10,y=1,z;
while(y<18&&x%10==0)x/=10,y++;
z=W(x);
for(int i=y;i>=1;i--){
int B=A-A%10+f[i][z][A%10]+w[i],C=g[i][z][A%10];
if(B<m&&C<=n){p=1,A=B,n-=C;break;}
}
}while(p);
if(!n)break;
n--,A=(A+W(A))%m;
if(A<9){
if(P[A])n%=(P[A]-n);
else P[A]=n;
}
if(!n)break;
}
cout<<A;
}
T3
注意到结论就是肯定是一直走一条链,然后到一个分叉点分开两条链,一个走到1,一个走到n,证明就是如果分叉过后还会相交,显然可以在后面分叉更优,然后就对每一个点假设它是分叉点,跑到分别到1或n的最短路,然后对于每个点,再跑到分叉点的最短路就行了,然后就是线段树优化建图(显然这是终点到起点,建返图),儿子连0边到父亲,线段树节点连1边到单点,显然这个可以边权变点权。
#include<bits/stdc++.h>
#define ls (k*2)
#define rs (ls+1)
#define lm ((l+r)/2)
#define rm (lm+1)
using namespace std;
const int N=2e5+5,M=N*4;
int n,L[N],R[N],f[3][M],a[N],W[M];
basic_string<int> g[M];
priority_queue< pair<int,int> > q;
void build(int k,int l,int r){
f[0][k]=f[1][k]=f[2][k]=N;
if(l==r){a[l]=k,W[k]=1;return;}
g[ls]+=k,g[rs]+=k;
build(ls,l,lm),build(rs,rm,r);
}
void modify(int k,int l,int r,int s,int t,int x){
if(l>t||r<s)return;
if(l>=s&&r<=t){g[k]+=x;return;}
modify(ls,l,lm,s,t,x),modify(rs,rm,r,s,t,x);
}
void dick(int d[]){
for(int i=1;i<=n;i++)if(d[a[i]]<N)q.push({-d[a[i]],a[i]});
while(!q.empty()){
auto [D,u]=q.top();q.pop();
if(-D>d[u])continue;
for(int v:g[u]){
int w=d[u]+W[v];
if(d[v]>w)d[v]=w,q.push({-w,v});
}
}
}
int main(){
freopen("treasure.in","r",stdin);
freopen("treasure.out","w",stdout);
ios::sync_with_stdio(0),cin.tie(0);
cin>>n;
for(int i=1;i<=n;i++)cin>>L[i]>>R[i];
build(1,1,n);
for(int i=1;i<=n;i++)modify(1,1,n,L[i],R[i],a[i]);
for(int i=1;i<=n;i++)if(L[i]==1)f[0][a[i]]=1;
dick(f[0]);
for(int i=1;i<=n;i++)if(R[i]==n)f[1][a[i]]=1;
dick(f[1]);
for(int i=1;i<=n;i++)f[2][a[i]]=f[0][a[i]]+f[1][a[i]]-1;
dick(f[2]);
int q;cin>>q;
while(q--){int x;cin>>x,cout<<(f[2][a[x]]<N?f[2][a[x]]:-1)<<'\n';}
}
9.24
T1
显然肯定3个直接消掉是最优的,然后我们先操作一次,之后就一定会剩下一个值了,肯定是a或b(a=最小值,b=中间值,c=最大值),定义一轮就是操作完后还剩下a,分类讨论3个数的大小关系,肯定我们想让越小的值消耗越少对吧,所以先多消耗c直到跟b相同,每个操作就是加入bc,然后保留b,然后加入ac,最后保留a,发现这一轮消耗了1个a,b,两个c,然后做若干轮要么a=0(结束),要么b=c,先讨论b=c,那么继续考虑让b,c变得和a相同,我们发现可以一轮可以做4次,加入bc,保留b,加入ac,保留a,加入bc,保留c,加入ab,保留a,这样a消耗了2次,b,c消耗了3次,做若干轮要么a变成0(结束),要么a=b=c,要么b=0(结束),然后三个相等的可以做3轮,每个消耗2次,然后肯定最后剩下O(1)个,直接暴力跑就行了。
T2
题面及其吓人,其实就是诈骗题。首先同层之间的贡献是固定的,无论你怎么排列,都是当前层的深度*2减去所有点的lca的深度,因为你至少会跨过一次子树,层间的贡献一定最多比同层的贡献多1,所以说只考虑同层的最大值K0,K>K0就一定合法每层内部可以任意排列,K<K0就一定不合法,只用考虑K=K0。那么同层的肯定没限制,层间的要有限制,这看似还是很困难,但是你会惊奇的发现,只要一个点和下一层的一个节点有限制,那么这个点一定和下一层所有节点有限制,我们考虑限制这个点的lca,那么其他下一层被这个点限制的点一定在这个点的lca的另一颗子树里,如果跟这个点在同一颗子树,那么这个点可以跟同层的另外的点产生限制,那层间的限制就不是最紧的了。所以我们就可以枚举同层限制最紧的层,然后对于每个点判断它跟任意一个下一层的点的lca是否是这层的限制lca就做完了。
T3
首先等价于排列,因为钦定这个排序是稳定排序就行了(所以开局可以先离散化一下)。首先a+b<=n两边是独立的,简单分讨论就行。然后a+b>n,以后令b=n-b+1,首先一定是交替操作吗,而且一次最多可以输送\(L=b-a+1\)个数,可以分类讨论先操作左边还是先操作右边,这里以先操作左边为例,那我们左边想要走的就是现在在[1,a],想要到(a,n]的个数A,右边想要走的就是现在在(a,n],想要到[1,b]的个数B,那么答案就是max(A/L,B/L+1)(都是向上取整)因为右边晚做一次,所以要加一。同理,右边先做也是一样,两个答案取min就行了,最后还要对2取max,因为0/1要先特判,因为这两个需要要求原序列的顺序,而>=2次则只有考虑值域了,维护ABCD可以用离散化后的值域树状数组扫描线简单维护。
#include<bits/stdc++.h>
#define pii array<int,2>
using namespace std;
const int N=2e5+5;
int n,q,a[N],t[N],pre[N],A[N],B[N],C[N],D[N];
pii b[N],Q[N];
basic_string<int> ga[N],gb[N],gc[N],gd[N];
void add(int x){for(;x<=n;x+=x&-x)t[x]++;}
int ask(int x){int y=0;for(;x;x-=x&-x)y+=t[x];return y;}//pre sum
int d(int x,int y){return (x+y-1)/y;}
int main(){
ios::sync_with_stdio(0),cin.tie(0);
cin>>n>>q;
for(int i=1;i<=n;i++)cin>>b[i][0],b[i][1]=i;
sort(b+1,b+n+1,[&](pii x,pii y){return x[0]!=y[0]?x[0]<y[0]:x[1]<y[1];});
for(int i=1;i<=n;i++)a[b[i][1]]=i;
for(int i=1;i<=q;i++){
int &X=Q[i][0],&Y=Q[i][1];
cin>>X>>Y,Y=n-Y+1;
ga[X]+=i,gb[X+1]+=i,gc[Y]+=i,gd[Y-1]+=i;
}
for(int i=1;i<=n;i++){
add(n+1-a[i]);
for(int j:ga[i])A[j]=ask(n-Q[j][0]);
for(int j:gd[i])D[j]=ask(n-Q[j][0]);
}
for(int i=1;i<=n;i++)t[i]=0;
for(int i=n;i>=1;i--){
add(a[i]);
for(int j:gb[i])B[j]=ask(Q[j][1]-1);
for(int j:gc[i])C[j]=ask(Q[j][1]-1);
}
for(int i=1;i<=n;i++)pre[i]=pre[i-1]+(a[i]!=i);
for(int i=1;i<=q;i++){
int X=Q[i][0],Y=Q[i][1];
if(!pre[n])cout<<0;
else if(!pre[Y-1]||!(pre[n]-pre[X]))cout<<1;
else{
int L=X-Y+1;
if(L<=0)cout<<(pre[Y-1]-pre[X]||A[i]||C[i]?-1:2);
else cout<<max(2,min(max(d(A[i],L)*2,d(B[i],L)*2+1),max(d(C[i],L)*2,d(D[i],L)*2+1)));
}
cout<<'\n';
}
return 0;
}
9.30
T1
要维护一个回字加,首先这种东西直接考虑二维差分,然后发现是对角线加/减,赛时太烫了,对于对角线加减又用二维差分维护了(二阶二维差分说是),实际上直接可以对于两个方向每个对角线分别维护个一维差分就行了。
下面是超级史代码,赛时调了一万年,还要处理神秘偏移量。
#include<bits/stdc++.h>
using namespace std;
const int N=1e3+5;
int n,k,p,a[2*N][2*N];
short b[5*N][5*N];
void A(int x1,int y1,int x2,int y2,int o){x1=min(x1,5*n+1),y1=min(y1,5*n+1),x2=min(x2,5*n+1),y2=min(y2,5*n+1),b[x1][y1]+=o,b[x1][y2]-=o,b[x2][y1]-=o,b[x2][y2]+=o;}
int main(){
freopen("universe.in","r",stdin);
freopen("universe.out","w",stdout);
ios::sync_with_stdio(0),cin.tie(0);
cin>>n>>k>>p;
for(int i=1;i<=k;i++){
int x,y,d;
cin>>x>>y>>d,x+=n,y+=n;
int lx=x-d+1,ly=y-d+1,rx=x+d,ry=y+d;
A(lx-ly+3*n,lx+ly,rx-ry+2+3*n,rx+ry+2,1),A(lx-ry+3*n,lx+ry,rx-ly+2+3*n,rx+ly+2,-1);
}
for(int i=2;i<=5*n;i++)for(int j=2;j<=5*n;j++)b[i][j]+=b[i-2][j]+b[i][j-2]-b[i-2][j-2];
for(int i=1;i<=2*n;i++)for(int j=1;j<=2*n;j++)a[i][j]=a[i-1][j]+a[i][j-1]-a[i-1][j-1]+b[i-j+3*n][i+j];
int ans=0;
for(int i=1;i<=n;i++)for(int j=1;j<=n;j++)ans+=a[i+n][j+n]<=p;
cout<<ans;
}
下面是吴浩岚同学的优美代码作对比
#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
const LL N=3e3+10;
LL n,m,p,ans;
int a[N][N],b[N][N],s[N][N];
int main()
{
freopen("universe.in","r",stdin);
freopen("universe.out","w",stdout);
scanf("%lld%lld%lld",&n,&m,&p);
for(int i=1;i<=m;i++)
{
LL x,y,w;
scanf("%lld%lld%lld",&x,&y,&w);
w--;
LL A=w,B=w+2;
a[x-A+n][y-A+n]++,a[x+B+n][y+B+n]--;
A=w+1,B=w;
b[x+1+A+n][y-A+n]++,b[x-B+n][y+B+1+n]--;
}
for(int i=1;i<=n*3;i++)
for(int j=1;j<=n*3;j++)
a[i][j]+=a[i-1][j-1],b[i][j]+=b[i-1][j+1],
s[i][j]=a[i][j]+b[i][j]+s[i-1][j]+s[i][j-1]-s[i-1][j-1];
for(int i=n+1;i<=2*n;i++)
for(int j=n+1;j<=2*n;j++)
ans+=(s[i][j]<=p);
printf("%lld",ans);
return 0;
}
T3
这种东西考虑dp拆贡献,发现每个\(a_i\)对于每个质数\(p_i\)要么贡献\(c_i\)个,要么贡献\(c_i-1\)个然后贡献一个\(p_i-1\),取决于之前有没有选过。所以就有一个朴素的状压dp,\(f_{i,s}\)表示考虑前i个数,选过了s集合里面的质数的答案,转移很简单。然后就是经典trick,考虑根号分治,\(<=\sqrt V\)的质数状压,然后大于的质数每个a只会有一个,对于相同大质数的a放在一起考虑。那么就有新的dp,\(f_{i,s,0/1}\)表示考虑的当前类别的前i个数,小质数选的集合为s,是否选过大质数,然后转移跟之前差不多,到下一个类别的时候处理一下就行了。
#include<bits/stdc++.h>
#define int long long
using namespace std;
const int N=3005,M=1<<16,P[]={2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53},p=998244353;
int n,a[N],b[N],f[2][M],inv[N],phi[M];
basic_string<int> g[N];
void A(int &x,int y){x=(x+y)%p;}
signed main(){
freopen("math.in","r",stdin);
freopen("math.out","w",stdout);
ios::sync_with_stdio(0),cin.tie(0);
inv[0]=inv[1]=1;
for(int i=2;i<=3000;i++)inv[i]=inv[p%i]*(p-p/i)%p;
for(int i=0;i<M;i++){
phi[i]=1;
for(int j=0;j<16;j++)if(i>>j&1)phi[i]=phi[i]*(P[j]-1)%p*inv[P[j]]%p;
}
cin>>n;
for(int i=1;i<=n;i++){
cin>>a[i];int x=a[i];
for(int j=0;j<16;j++)while(x%P[j]==0)x/=P[j],b[i]|=1<<j;
g[x]+=i;
}
f[0][0]=1;
for(int i=1;i<=3000;i++)if(!g[i].empty()){
for(int x:g[i]){
for(int j=M-1;j>=0;j--){
int s=b[x]-(j&b[x]);
A(f[1][j|s],(f[0][j]*max(1ll,i-1)%p*inv[i]%p+f[1][j]%p)%p*a[x]%p*phi[s]%p);
}
}
for(int j=0;j<M;j++)A(f[0][j],f[1][j]),f[1][j]=0;
}
int ans=0;
for(int i=0;i<M;i++)A(ans,f[0][i]);
cout<<ans<<'\n';
}
浙公网安备 33010602011771号