Codeforces Round #467 (div.2)

我才不会打这种比赛呢

（其实本来打算打的）

谁叫它推迟到了\(00:05\)

我爱睡觉

题解

A. Olympiad

翻译

给你若干人的成绩

让你划定一个分数线

使得所有不低于这个分数线的人都可以获奖

但是\(0\)分的人一定不能得奖

问你有多少种获奖情况

题解

\(sort+unique\) 然后判断一下最小值是不是\(0\)就行了

#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 n,a[500];

int main()

{

	n=read();

	for(int i=1;i<=n;++i)a[i]=read();

	sort(&a[1],&a[n+1]);

	int tot=unique(&a[1],&a[n+1])-a-1;

	if(a[1]==0)tot--;

	printf("%d\n",tot);

	return 0;

}

B. Vile Grasshoppers

翻译

给定\(p,y\)

在\(2..y\)内找到一个最大值\(x\)

使得\(x\)不能被\(2..p\)整除

无解输出\(-1\)

题解

看到范围这么大。

真是吓死人

首先考虑一下怎么检查一个值\(x\)是否可行

当然不需要枚举\(2..p\)

最多只需要枚举到\(\sqrt x\)

如果有解，要么\(p\)很小，要么\(y\)很大

很容易就可以枚举出来

如果无解，\(p\)一定要很接近\(y\)

这样不需要枚举多少个数

复杂度\(O(???)\)

#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

ll ans=0;

int main()

{

	int p,y;

	cin>>p>>y;

	for(int ans=y;ans>p;--ans)

	{

		bool fl=true;

		for(int i=2;i<=p&&i*i<=ans;++i)

			if(ans%i==0){fl=false;break;}

		if(fl){cout<<ans<<endl;return 0;}

	}

	puts("-1");

	return 0;

}

C. Save Energy!

翻译

有一个人要煮鸡吃

但是炉子每过\(k\)分钟就会自动关上

这个人每过\(d\)分钟会进厨房，如果炉子关上了他就会打开

炉子在打开的时候鸡只需要\(t\)分钟就可以煮熟

在关上的时候则需要\(2t\)分钟

问这个人多久以后可以吃到鸡

题解

这题很简单啊

首先如果\(K\%d=0\)就不用考虑了

否则我们一定能够找到一个最小的\(x\)

使得\(xd>K\)

这样子的话，我们发现开关状态以\(xd\)循环

接下来只要分类讨论就行了

#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

ll K,d,t;

int main()

{

	cin>>K>>d>>t;t*=2;

	if(K%d==0){cout<<t/2<<endl;return 0;}

	ll st=K/d+1;

	ll T=st*d;

	ll ts=2*K+(T-K);

	double ans=t/ts*T;t%=ts;

	if(t<=2*K)ans+=t/2.0;

	else

	{

		ans+=K;

		t-=2*K;

		ans+=t;

	}

	printf("%.10lf\n",ans);

	return 0;

}

D. Sleepy Game

翻译

有两个人在玩一个游戏

有一个棋子和有向图

一开始棋子在某个位置

然后两个人轮流走

谁先走不了谁就输了

如果超过了\(10^6\)步则平局

但是现在第二个人睡觉去了

两个人都由第一个人操控

问第一个人能不能赢，如果能输出路径

否则输出平局或者必败

题解

首先考虑能不能赢

因为能不能赢

只和到达一个出度为\(0\)的点的路径的奇偶性有关

所以用一个\(BFS\)检查能否以某个奇偶性到达某个点

如果有出度为\(0\)的点满足条件，则输出路径

考虑平局，即能够到达某个环

第一步检查了能否到达

这样找到环以后判断一下就好

如果也不能平局，则必败，输出即可

#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;

}

struct Line{int v,next;}e[MAX*2];

int h[MAX],cnt=1,n,m,H[MAX],B;

int dis[MAX][2],zy[MAX][2];

inline void Add(int u,int v){e[cnt]=(Line){v,h[u]};h[u]=cnt++;}

void outp(int now,int k,int w)

{

	if(!(k==now&&!w))outp(now,zy[k][w],w^1);

	printf("%d ",k);

}

bool bfs(int now)

{

	queue<pair<int,int> >Q;

	Q.push(make_pair(now,0));

	dis[now][0]=1;

	while(!Q.empty())

	{

		int u=Q.front().first,w=Q.front().second;Q.pop();

		for(int i=h[u];i;i=e[i].next)

		{

			int v=e[i].v;

			if(dis[v][w^1])continue;

			zy[v][w^1]=u;

			dis[v][w^1]=1;

			Q.push(make_pair(v,w^1));

		}

	}

	for(int i=1;i<=n;++i)

		if(!H[i]&&dis[i][1])

		{

			puts("Win");outp(now,i,1);puts("");

			return true;

		}

	return false;

}

int dfn[MAX],low[MAX],tim;

int S[MAX],top,G[MAX];

bool vis[MAX];

bool Ans;

void Tarjan(int u)

{

	S[++top]=u;vis[u]=true;

	dfn[u]=low[u]=++tim;

	for(int i=h[u];i;i=e[i].next)

	{

		int v=e[i].v;

		if(!dfn[v])Tarjan(v),low[u]=min(low[u],low[v]);

		else if(vis[v])low[u]=min(low[u],dfn[v]);

	}

	if(dfn[u]==low[u])

	{

		int v,size=0;

		do{v=S[top--];vis[v]=false;G[++size]=v;}while(u!=v);

		if(size!=1)

			for(int i=1;i<=size;++i)

				if(dis[G[i]][0]||dis[G[i]][1])Ans=true;

	}

}

int main()

{

	n=read();m=read();

	for(int i=1;i<=n;++i)

	{

		H[i]=read();

		for(int j=1;j<=H[i];++j)Add(i,read());

	}

	B=read();

	if(bfs(B))return 0;

	for(int i=1;i<=n;++i)if(!dfn[i])Tarjan(i);

	if(Ans)puts("Draw");

	else puts("Lose");

	return 0;

}

E. Lock Puzzle

翻译

给定一个串\(s\)和目标串\(s'\)

你每次都可以执行一个\(shift\)操作

执行\(shift(x)\)后

假设原来的串是\(s=AB\)

那么，现在的串变为了\(B^RA\)

其中，\(B\)的长度等于\(x\)

说白点，就是把后\(x\)个字符翻转后，放在字符串的最前面

（举个例子，原来是\(ababc\) ，执行\(shift(3)\)后，变为了\(cbaab\)）

执行操作的次数不能超过\(6100\)次

无解输出\(-1\)

题解

我们假设前面已经匹配好了\(i-1\)位

现在匹配第\(j\)位

那么，现在当前串中找到一个和目标位置相同的字符，位置是\(pos\)

然后考虑\(shift\)操作

当然，只需要执行\(shift(n-pos),shift(1),shift(n)\)三次操作就行了

我们假设当前串是\(AcB\)其中\(c=s[pos]\)

\(shift(n-pos)\)之后\(B^RAc\)

\(shift(1)\)之后\(cB^RA\)

\(shift(n)\)之后\(A^RBc\)

这样的话，我们发现后面的位置就不会再变化了

而每次我们都把当前的目标字符给挪到了最后一个位置

这样执行\(3n\)次操作之后就可以得到目标串了

#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 5000

int n,a[26],b[26];

char s[MAX],ss[MAX];

char s1[MAX],s2[MAX];

vector<int> ans;

void shift(char *s,int x)

{

	int t1=0,t2=0;

	for(int i=n-x+1;i<=n;++i)s2[++t2]=s[i];

	reverse(&s2[1],&s2[t2+1]);

	for(int i=1;i<=n-x;++i)s1[++t1]=s[i];

	for(int i=1;i<=x;++i)s[i]=s2[i];

	for(int i=1;i<=t1;++i)s[i+t2]=s1[i];

	ans.push_back(x);

}

int main()

{

	scanf("%d",&n);

	scanf("%s",s+1);

	scanf("%s",ss+1);

	for(int i=1;i<=n;++i)a[s[i]-97]++,b[ss[i]-97]++;

	for(int i=0;i<26;++i)if(a[i]!=b[i]){puts("-1");return 0;}

	for(int i=1;i<=n;++i)

	{

		int pos;

		for(int j=1;j<=n;++j)

			if(s[j]==ss[i]){pos=j;break;}

		shift(s,n-pos);shift(s,1);shift(s,n);

	}

	printf("%d\n",(int)(ans.size()));

	for(int i=0;i<ans.size();++i)

		printf("%d ",ans[i]);

	return 0;

}