其他分享
首页 > 其他分享> > CodeTON Round 2(持续更新中)

CodeTON Round 2(持续更新中)

作者:互联网

Preface

现在菜的真实啊……比赛的时候打的慢就算了还天天写假算法,可怜……

ABCD用了1h,然后E以为不会爆long long(主要我的做法很奇怪很脑残),当场去世


A. Two 0-1 Sequences

签到题,首先我们发现一个先决条件:a的后\(m-1\)位必须和b的后\(m-1\)位相等,因为修改影响不到后面

我们发现操作的本质就是在a的前\(n-m+1\)位中任选一个保留下来,因此只需要看这些数中有没有和b的首位相同的即可

#include<cstdio>
#include<iostream>
#include<algorithm>
#define RI register int
#define CI const int&
using namespace std;
const int N=55;
int t,n,m; char a[N],b[N];
int main()
{
	//freopen("CODE.in","r",stdin); freopen("CODE.out","w",stdout);
	for (scanf("%d",&t);t;--t)
	{
		RI i,pos=0; scanf("%d%d%s%s",&n,&m,a+1,b+1);
		for (i=1;i<=m;++i) if (a[n-i+1]!=b[m-i+1]) { pos=i; break; }
		if (!pos) { puts("YES"); continue; }
		if (pos!=m) { puts("NO"); continue; }
		bool flag=0; for (i=1;i<=n-m+1;++i)
		if (a[i]==b[1]) { flag=1; break; }
		puts(flag?"YES":"NO");
	}
	return 0;
}

B. Luke is a Foodie

不难发现对于一个区间\([l,r]\),它们可以被同一个数一起拿走的充要条件是\(\max_{l\le i\le r} a_i-\min_{l\le i\le r} a_i\le 2x\)

由于我们必须按顺序取走每一个数,因此直接从左往右贪心,每次取走能取的最大的区间即可

#include<cstdio>
#include<iostream>
#include<algorithm>
#define RI register int
#define CI const int&
using namespace std;
const int INF=1e9;
int t,n,m,x,mi,mx,ans;
int main()
{
	//freopen("CODE.in","r",stdin); freopen("CODE.out","w",stdout);
	for (scanf("%d",&t);t;--t)
	{
		RI i; for (scanf("%d%d",&n,&m),mi=INF,ans=mx=0,i=1;i<=n;++i)
		{
			scanf("%d",&x); mi=min(mi,x); mx=max(mx,x);
			if (mx-mi>2*m) ++ans,mx=mi=x;
		}
		printf("%d\n",ans);
	}
	return 0;
}

C. Virus

首先把所有被病毒分割开的区间算出来,如果不考虑堵上感染的话每天这些区间长度就会减\(2\)

考虑堵上的顺序,一开始以为随便怎么堵对答案都没影响,因为每次总减去的数目不变

后来发现对于长度为1和2的区间,即使堵住了也没法拯救更多的了,因此我们贪心地从长的区间开始堵即可

#include<cstdio>
#include<iostream>
#include<algorithm>
#define RI register int
#define CI const int&
using namespace std;
const int N=100005;
int t,n,m,a[N],b[N],cnt,ans;
int main()
{
	//freopen("CODE.in","r",stdin); freopen("CODE.out","w",stdout);
	for (scanf("%d",&t);t;--t)
	{
		RI i; for (scanf("%d%d",&n,&m),i=1;i<=m;++i) scanf("%d",&a[i]);
		for (sort(a+1,a+m+1),i=1;i<m;++i) b[i]=a[i+1]-a[i]-1;
		b[m]=n-a[m]+a[1]-1; sort(b+1,b+m+1);
		for (ans=cnt=0,i=m;i;--i) if (b[i]-cnt*2>0)
		{
			if (b[i]-cnt*2<=2) ++cnt,++ans; else ans+=b[i]-cnt*2-1,cnt+=2;
		} else break;
		printf("%d\n",n-ans);
	}
	return 0;
}

D. Magical Array

STO YKH ORZ

不难发现这个两种操作都很像差分,因此我们把\(c_i\)的前缀和数组\(s_i\)求出

然后我们发现操作1对\(\sum_{i=1}^m s_i\)的大小是没影响的,而每一次操作2会让\(\sum_{i=1}^m s_i\)的值减1

发现这个性质后就很简单了

#include<cstdio>
#include<iostream>
#include<algorithm>
#define int long long
#define RI register int
#define CI const int&
using namespace std;
const int N=300005;
int t,n,m,x,pre,f[N];
signed main()
{
	//freopen("CODE.in","r",stdin); freopen("CODE.out","w",stdout);
	for (scanf("%lld",&t);t;--t)
	{
		RI i,j,p,c; for (scanf("%lld%lld",&n,&m),i=1;i<=n;++i)
		for (pre=f[i]=0,j=1;j<=m;++j) scanf("%lld",&x),pre+=x,f[i]+=pre;
		for (i=1;i<n;++i) if (f[i]!=f[i+1]) { p=i; break; }
		for (c=0,i=1;i<=n;++i) if (f[i]==f[p]) ++c;
		if (c==n-1) printf("%lld %lld\n",p+1,f[p]-f[p+1]); else printf("%lld %lld\n",p,f[p+1]-f[p]);
	}
	return 0;
}

E. Count Seconds

我的做法很蠢权当娱乐的说

首先数据范围很小我们考虑暴力,朴素的直接枚举时间的方法肯定不可行

因此我们想到每次找出\(a_i\)不为0且最小的入度为0的点\(p\),然后让时间经过\(a_p\),这样这个点就被永久剔除了

然后写完就发现会出现前面的点值不为0而后面的点值为0导致的堵塞行为(其实就是样例2)

但是YKHdalao敏锐地发现了在经过\(n-1\)次操作后,必然会形成如果点\(i\)满足\(a_i\ne 0\),那么它能到达的所有点\(j\)一定满足\(a_j\ne 0\)的局面,就可以用上面的方法做了

然后我就开始写,随后又发现取模之后我们没法正确的找出最小值了

但是由于我们这里只需要能比较数据的大小关系,不妨把一个数表示成\(A\times 998244353+B(B<998244353)\)的形式

因为\(A\)不参与答案计算,因此直接用long double暴力存下\(A\)大致量级即可完成比较操作

复杂度\(O(n^2)\)

#include<cstdio>
#include<iostream>
#include<vector>
#include<algorithm>
#define RI register int
#define CI const int&
using namespace std;
const int N=1005,mod=998244353;
typedef vector <int>:: iterator VI;
int t,n,m,x,y,in[N],a[N],b[N],vis[N],tar,timm; vector <int> v[N];
struct data
{
	long double p; int r;
	friend inline bool operator < (const data& A,const data& B)
	{
		if (A.p<B.p) return 1; if (A.p>B.p) return 0; return A.r<B.r;
	}
	friend inline data operator + (const data& A,const data& B)
	{
		data C; if (A.r+B.r>=mod) C=(data){A.p+B.p+1,A.r+B.r-mod};
		else C=(data){A.p+B.p,A.r+B.r}; return C;
	}
	friend inline data operator - (const data& A,const data& B)
	{
		data C; if (A.r-B.r<0) C=(data){A.p-B.p-1,A.r-B.r+mod};
		else C=(data){A.p-B.p,A.r-B.r}; return C;
	}
	friend inline data operator * (CI x,const data& B)
	{
		int P=1LL*x*B.r/mod,R=1LL*x*B.r%mod; return (data){x*B.p+P,R};
	}
}c[N],tim;
inline bool check(void)
{
	for (RI i=1;i<=n;++i) if (a[i]) return 1; return 0;
}
inline int add(CI x,CI y)
{
	return x+y>=mod?x+y-mod:x+y;
}
int main()
{
	//freopen("CODE.in","r",stdin); freopen("CODE.out","w",stdout);
	for (scanf("%d",&t);t;--t)
	{
		RI i,j; for (scanf("%d%d",&n,&m),i=1;i<=n;++i)
		scanf("%d",&a[i]),v[i].clear(),in[i]=vis[i]=0;
		for (i=1;i<=m;++i) scanf("%d%d",&x,&y),++in[y],v[x].push_back(y);
		for (i=1;i<=n;++i) if (!v[i].size()) tar=i; timm=0;
		for (;timm<=n&&check();++timm)
		{
			for (i=1;i<=n;++i) b[i]=0;
			for (i=1;i<=n;++i) if (a[i])
			{
				--b[i]; for (VI it=v[i].begin();it!=v[i].end();++it) ++b[*it];
			}
			for (i=1;i<=n;++i) a[i]+=b[i];
		}
		if (!check()) { printf("%d\n",timm); continue; }
		for (i=1;i<=n;++i) c[i]=(data){0,a[i]}; tim=(data){0,timm};
		for (;;)
		{
			if (!in[tar]) { printf("%d\n",add(c[tar].r,tim.r)); break; }
			int p=0; data mi; for (i=1;i<=n;++i)
			if (!in[i]&&!vis[i]) if (!p||c[i]<mi) mi=c[i],p=i;
			for (i=1;i<=n;++i) c[i]=c[i]-mi+(in[i]*mi); tim=tim+mi; vis[p]=1;
			for (VI it=v[p].begin();it!=v[p].end();++it) --in[*it];
		}
	}
	return 0;
}

PS:看了sol发现我就是个睿智,连拓扑排序都想不到

直接把拓扑序求出来之后按序把\(a_i\)加到后面相连的点即可,不过仍然需要前面的\(n-1\)次爆枚来保证没有0点堵塞


标签:const,int,CodeTON,更新,RI,freopen,include,Round,define
来源: https://www.cnblogs.com/cjjsb/p/16543315.html