Codeforces Round #466 (Div. 2)

所有的题目都可以在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;
}