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
",ans[i]);
	return 0;
}