所有的题目都可以在CodeForces上查看
中间看起来有很多场比赛我没有写了
其实是因为有题目没改完
因为我不想改,所以就没有写了(大部分题目还是改完了的)
我还是觉得如果是打了的比赛就一场一场写比较好
要不然以后就写有难度的、比较好的题目??
这场比赛时间真心良心(只是没吃饭)
状态也很好,考场上把\(ABCDE\)切了
\(F\)是自己弃疗了。。。
不管啦不管啦,进入正题了
题解
A.Points on the line
翻译:
给定一个长度为\(n\)的数组
问最少删去几个数之后使得最大值减最小值的结果小于等于\(d\)
题解
考虑\(n\)的范围很小
排序之后枚举每一段区间,计算答案即可
#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<algorithm>
#include<set>
#include<map>
#include<vector>
#include<queue>
using namespace std;
#define ll long long
#define RG register
inline int read()
{
RG int x=0,t=1;RG char ch=getchar();
while((ch<'0'||ch>'9')&&ch!='-')ch=getchar();
if(ch=='-')t=-1,ch=getchar();
while(ch<='9'&&ch>='0')x=x*10+ch-48,ch=getchar();
return x*t;
}
int a[200],n,D;
int main()
{
n=read();D=read();
for(int i=1;i<=n;++i)a[i]=read();
sort(&a[1],&a[n+1]);
int ans=0;
for(int i=n;i;--i)
{
ans++;
for(int j=1;j+i-1<=n;++j)
if(a[j+i-1]-a[j]<=D)
{
cout<<ans-1<<endl;
return 0;
}
}
}
B.Our Tanya is Crying Out Loud
翻译
给定\(n,k,A,B\),
一开始\(x=n\),
每次可以花费$A \(的代价 使得\)x=x-1$ ;
每次可以花费\(B\)的代价
使得\(x=x/k\)(前提是\(x\%k=0\))
问使得\(x\)变成\(0\)的最小代价
题解
每次贪心的考虑把\(x\)变成\([\frac{x}{k}]\)的代价
看看是一个个减更优还是先减再除更优
#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<algorithm>
#include<set>
#include<map>
#include<vector>
#include<queue>
using namespace std;
#define ll long long
#define RG register
inline int read()
{
RG int x=0,t=1;RG char ch=getchar();
while((ch<'0'||ch>'9')&&ch!='-')ch=getchar();
if(ch=='-')t=-1,ch=getchar();
while(ch<='9'&&ch>='0')x=x*10+ch-48,ch=getchar();
return x*t;
}
ll n,K,A,B;
int main()
{
n=read();K=read();A=read();B=read();
ll ans=0;
if(n<K){ans=A*(n-1);cout<<ans<<endl;return 0;}
if(K==1){ans=A*(n-1);cout<<ans<<endl;return 0;}
while(n!=1)
{
if(n<K)
{
ans+=A*(n-1);
cout<<ans<<endl;
return 0;
}
ll gg=n/K;
ll t1=(n-gg)*A;
ll t2=(n%K)*A+B;
ans+=min(t1,t2);
n=gg;
}
cout<<ans<<endl;
return 0;
}
C.Phone Numbers
翻译
给定一个长度为\(n\)的串\(S\)
要求只能用\(n\)中包含的字符构建一个长度为\(k\)的字符串\(T\)
使得\(T\)的字典序最小,并且\(S\)的字典序小于\(T\)
题解
如果\(k>n\)直接把\(S\)复制一遍
后面填字典序最小的字符就行了
否则的话,把两个字符串从首位开始对齐
从\(T\)的末尾开始填
只要\(S\)的当前位置不是字典序最大的字符
就填上比它大的字符
然后前面直接复制
#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<algorithm>
#include<set>
#include<map>
#include<vector>
#include<queue>
using namespace std;
#define ll long long
#define RG register
int n,k;
char ch[120000];
int ans[120000];
int g[120000];
int main()
{
cin>>n>>k;
scanf("%s",ch+1);
for(int i=1;i<=n;++i)g[i]=ch[i]-96;
sort(&g[1],&g[n+1]);
int t=unique(&g[1],&g[n+1])-g-1;
if(k>n)
{
for(int i=1;i<=n;++i)putchar(ch[i]);
for(int i=n+1;i<=k;++i)putchar(g[1]+96);
puts("");
return 0;
}
bool fl=false;
for(int i=k;i;--i)
{
int c=ch[i]-96;
if(fl){ans[i]=c;continue;}
if(c==g[t])ans[i]=g[1];
else
{
ans[i]=g[lower_bound(&g[1],&g[t+1],c)-g+1];
fl=true;
}
}
for(int i=1;i<=k;++i)putchar(ans[i]+96);
puts("");
return 0;
}
D.Alena And The Heater
翻译
很难翻译呀,配着英文看还是挺好的
给定你一个数列\(A\)
以及让你构造的\(01\)串\(B\)
满足以下条件:
\(b[1]=b[2]=b[3]=b[4]=0\)
\(b[i]=1\),当满足:
\[a_i,?a_{i?-?1},?a_{i?-?2},?a_{i?-?3},?a_{i?-?4}?>r?\ and\ b_{i?-?1}?=?b_{i?-?2}?=?b_{i?-?3}?=?b_{i?-?4}?=?1\]
\(b[i]=0\),当满足:
\[a_i,?a_{i?-?1},?a_{i?-?2},?a_{i?-?3},?a_{i?-?4}?<l?\ and\ b_{i?-?1}?=?b_{i?-?2}?=?b_{i?-?3}?=?b_{i?-?4}?=?0\]
如果都不满足上面的两种情况
那么\(b[i]=b[i-1]\)
保证题目有解
输出能够构造出\(B'\)的\(l,r\)
题解
这题的关键在哪里?
保证题目有解
所以每次只需要找到\(01\)变化的地方
相应的对\(l/r\)取一个\(max/min\)
很简单吧
#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<algorithm>
#include<set>
#include<map>
#include<vector>
#include<queue>
using namespace std;
#define ll long long
#define RG register
#define MAX 120000
inline int read()
{
RG int x=0,t=1;RG char ch=getchar();
while((ch<'0'||ch>'9')&&ch!='-')ch=getchar();
if(ch=='-')t=-1,ch=getchar();
while(ch<='9'&&ch>='0')x=x*10+ch-48,ch=getchar();
return x*t;
}
int n,a[MAX],b[MAX],bb[MAX];
char ch[MAX];
int p[MAX],pp[MAX];
int q[MAX];
int main()
{
n=read();
for(int i=1;i<=n;++i)a[i]=read();
scanf("%s",ch+1);
for(int i=1;i<=n;++i)bb[i]=ch[i]-48;
for(int i=5;i<=n;++i)
{
p[i]=min(a[i],a[i-1]);
p[i]=min(p[i],a[i-2]);
p[i]=min(p[i],a[i-3]);
p[i]=min(p[i],a[i-4]);
}
for(int i=5;i<=n;++i)
{
q[i]=max(a[i],a[i-1]);
q[i]=max(q[i],a[i-2]);
q[i]=max(q[i],a[i-3]);
q[i]=max(q[i],a[i-4]);
}
for(int i=4;i<=n;++i)
{
if(b[i]==b[i-1]&&b[i]==b[i-2]&&b[i]==b[i-3])
pp[i]=b[i];
else pp[i]=2;
}
int l=-1e9,r=1e9,now=0;
for(int i=5;i<=n;++i)
{
if(bb[i]!=bb[i-1])
{
if(bb[i]==1)l=max(l,q[i]+1);
else r=min(r,p[i]-1);
}
}
cout<<l<<' '<<r<<endl;
return 0;
}
E. Cashback
翻译
给定长度为\(n\)的序列\(a\),以及一个\(k\)
你可以把他划分成若干段
设某一段的长度为\(len\)
那么,这一段就会删去\([\frac{len}{k}]\)个最小的数
求出这个序列能够划分出的最小和
题解
\(O(n^2)\)的\(dp\)是很显然的
\[f[i]=min(f[j]+Calc(j+1,i))\]
\(Calc\)貌似要用主席树?,
复杂度还要套个\(log\)
但是,我们真的有必要这么做吗?
仔细观察分段
如果我们分出一个长度为\(2k\)的段
似乎不会比分成两段长度为\(k\)的更优
因为两段\(k\)中是分别删去最小值
而一段\(2k\)中删去的是最小的两个值
所以,我们就可以知道分段的时候长度分成\(k\)
而不是更多的连续在一起的值
那么,分成\(k+p(p<k)\)有没有意义呢?
数字越多,最小值是单调递减的
那么,分成这样的一组不会比分出一段\(k\)更优
而分出一段\(p\)
等价于分出\(p\)个\(1\)
所以,其实我们的转移没有必要\(O(n)\)来做
只需要考虑是分出一段\(k\)
还是分出一个\(1\)就行了
每次分出一段\(k\)就要删去一个数
所以要查找区间最小值
用\(ST\)表就行了
时间复杂度\(O(nlog)\)
我因为一开始写了主席树,索性用主席树算的答案
复杂度不变,\(O(nlog)\)
#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<algorithm>
#include<set>
#include<map>
#include<vector>
#include<queue>
using namespace std;
#define ll long long
#define RG register
#define MAX 120000
inline int read()
{
RG int x=0,t=1;RG char ch=getchar();
while((ch<'0'||ch>'9')&&ch!='-')ch=getchar();
if(ch=='-')t=-1,ch=getchar();
while(ch<='9'&&ch>='0')x=x*10+ch-48,ch=getchar();
return x*t;
}
int n,a[MAX],rt[MAX],S[MAX],tt;
ll s[MAX];
ll f[MAX];
int tot,c;
struct Node
{
int ls,rs;
ll sum;
int size;
}t[MAX<<5];
void Modify(int &now,int ff,int l,int r,int p,int w)
{
now=++tot;
t[now]=t[ff];t[now].size++;t[now].sum+=1ll*S[p]*w;
if(l==r)return;
int mid=(l+r)>>1;
if(p<=mid)Modify(t[now].ls,t[ff].ls,l,mid,p,w);
else Modify(t[now].rs,t[ff].rs,mid+1,r,p,w);
}
ll Query(int r1,int r2,int l,int r,int K)
{
if(l==r){return K*S[l];}
int mid=(l+r)>>1;
int ss=t[t[r2].ls].size-t[t[r1].ls].size;
if(K<=ss)return Query(t[r1].ls,t[r2].ls,l,mid,K);
else return t[t[r2].ls].sum-t[t[r1].ls].sum+Query(t[r1].rs,t[r2].rs,mid+1,r,K-ss);
}
int main()
{
n=read();c=read();
for(int i=1;i<=n;++i)S[++tt]=a[i]=read();
for(int i=1;i<=n;++i)s[i]=s[i-1]+a[i];
sort(&S[1],&S[n+1]);
tt=unique(&S[1],&S[tt+1])-S-1;
for(int i=1;i<=n;++i)
{
int p=lower_bound(&S[1],&S[tt+1],a[i])-S;
Modify(rt[i],rt[i-1],1,tt,p,1);
}
for(int i=1;i<c;++i)f[i]=s[i];
for(int i=c;i<=n;++i)
{
f[i]=f[i-1]+a[i];
ll gg=s[i]-s[i-c]-Query(rt[i-c],rt[i],1,tt,1);
f[i]=min(f[i],gg+f[i-c]);
}
cout<<f[n]<<endl;
return 0;
}
F. Machine Learning
翻译
给定一个长度为\(n\)的序列\(a\)
两种操作
1.询问\([l,r]\)区间内,所有数字出现次数的\(mex\)值
2.将\(p\)位置修改为\(x\)
其中\(mex\)表示的是最小的没有出现过的正整数
题解
很明显的莫队,带修改莫队
离线读入
离散之后维护每个数字出现的次数
其实没有必要对这个值进行类似于直接求\(mex\)的分块
因为出现次数在最坏情况下是\(1,2,3....\)
这个的和是平方级别的
所以\(mex\)一定是根号级别的
这样的话复杂就是对的了
但是细节很多
否则时间挂烂(比如我调了1个多小时)
#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<algorithm>
#include<set>
#include<map>
#include<vector>
#include<queue>
using namespace std;
#define ll long long
#define RG register
#define MAX 200000
inline int read()
{
RG int x=0,t=1;RG char ch=getchar();
while((ch<'0'||ch>'9')&&ch!='-')ch=getchar();
if(ch=='-')t=-1,ch=getchar();
while(ch<='9'&&ch>='0')x=x*10+ch-48,ch=getchar();
return x*t;
}
struct Event
{
int id;
int l,r,blk;
int lst;
}Q[MAX],P[MAX];
int ans[MAX];
int S[MAX<<1],ss,n,m,a[MAX],b[MAX],blk=3000,tot,q;
int sum[MAX],Sum[MAX];
int Blk[MAX];
bool cmp(Event a,Event b){
if(a.blk!=b.blk) return a.blk<b.blk;
if((a.r-1)/blk!=(b.r-1)/blk)return (a.r-1)/blk<(b.r-1)/blk;
return a.lst<b.lst;
}
void Change(int num,int w)
{
Sum[sum[num]]--;
if(Sum[sum[num]]==0)Blk[(Sum[sum[num]]-1)/500]--;
sum[num]+=w;
Sum[sum[num]]++;
if(Sum[sum[num]]==1)Blk[(Sum[sum[num]]-1)/500]++;
}
int GetAns()
{
for(int i=0;;++i)
{
if(Blk[i]==blk)continue;
for(int j=1;j<=blk;++j)
if(!Sum[i*blk+j])return i*blk+j;
}
}
void Modify(int st,int now,int l,int r)
{
if(st==now)return;
if(now<st)
for(int i=now+1;i<=st;++i)
{
a[P[i].l]=P[i].r;
if(P[i].l>=l&&P[i].l<=r)
{
Change(P[i].lst,-1);
Change(P[i].r,1);
}
}
else
for(int i=now;i>st;--i)
{
a[P[i].l]=P[i].lst;
if(P[i].l>=l&&P[i].l<=r)
{
Change(P[i].r,-1);
Change(P[i].lst,1);
}
}
}
void Work(int pos,int w)
{
Change(a[pos],w);
}
int main()
{
n=read();m=read();
for(int i=1;i<=n;++i)b[i]=a[i]=read(),S[++ss]=a[i];
for(int i=1;i<=m;++i)
{
int opt=read(),l=read(),r=read();
if(opt==1){Q[++q]=(Event){q,l,r,(l-1)/blk,tot};}
else
{
P[++tot]=(Event){tot,l,r,0,b[l]};
b[l]=r;
S[++ss]=r;
}
}
sort(&S[1],&S[ss+1]);
ss=unique(&S[1],&S[ss+1])-S-1;
for(int i=1;i<=n;++i)a[i]=lower_bound(&S[1],&S[ss+1],a[i])-S;
for(int i=1;i<=tot;++i)
{
P[i].r=lower_bound(&S[1],&S[ss+1],P[i].r)-S;
P[i].lst=lower_bound(&S[1],&S[ss+1],P[i].lst)-S;
}
sort(&Q[1],&Q[q+1],cmp);
int md=0,l=1,r=0;
for(int i=1;i<=q;++i)
{
while(r<Q[i].r)Work(++r,1);
while(l>Q[i].l)Work(--l,1);
while(r>Q[i].r)Work(r--,-1);
while(l<Q[i].l)Work(l++,-1);
Modify(Q[i].lst,md,l,r);
md=Q[i].lst;
ans[Q[i].id]=GetAns();
}
for(int i=1;i<=q;++i)
printf("%d\n",ans[i]);
return 0;
}