Educational Codeforces Round 73 (Rated for Div. 2) ABCDE

最新推荐文章于 2019-12-07 11:54:32 发布

henucm

最新推荐文章于 2019-12-07 11:54:32 发布

阅读量609

点赞数

分类专栏： CF

本文链接：https://blog.csdn.net/henucm/article/details/101221278

版权

CF 专栏收录该内容

32 篇文章 0 订阅

订阅专栏

传送门

A. 2048 Game

题意：给出一些数这些数都是2的指数，每次都可以任意选两个数相加，操作次数不限，问最后能否得到 2048

思路：转化成是2的多少次方存起来然后递归查询

#include<bits/stdc++.h>
using namespace std;
int find(int x)
{
	int ans=0;
	while(x!=1)
	{
		x>>=1;
		ans++;
	}
	return ans;
}
int main()
{
	int t;
	cin>>t;
	while(t--)
	{
		map<int,int>mp;
		int n;
		cin>>n;
		int flag=0;
		for(int i=1;i<=n;i++)
		{
			int x;
			cin>>x;
			if(x>2048)
			{
				continue;
			}
			else if(x==2048)
			{
				flag=1;
			}
			else
			{
				int w=find(x);
				mp[w]++;
			}
		}
		if(flag==1)
		{
			cout<<"YES"<<endl;
			continue;
		}
		for(int i=0;i<=10;i++)
		{
			int x=mp[i]/2;
			mp[i+1]+=x;
		}
		if(mp[11])
		{
			cout<<"YES"<<endl;
		}
		else
		{
			cout<<"NO"<<endl;
		}
	}
	return 0;
}

B. Knights

题意：有两种骑士可以相互攻击他们的位置必须满足

|x1−x2|=2 and |y1−y2|=1
|x1−x2|=1 and |y1−y2|=2.

问最多可以攻击多少次。随便画画大概就能猜到规律

#include<bits/stdc++.h>
using namespace std;
int main()
{
	int n;
	cin>>n;
	for(int i=1;i<=n;i++)
	{
		char c; 
		if(i&1)
		{
			c='W';
		}
		else
		{
			c='B';
		}
		for(int j=1;j<=n;j++)
		{
			cout<<c;
			if(c=='W')
			c='B';
			else
			c='W';
		}
		cout<<endl;
	}
	return 0;

C. Perfect Team

简单数学题

    #include<bits/stdc++.h>
    using namespace std;
    int main()
    {
    	int t;
    	cin>>t;
    	while(t--)
    	{
    		int c,m,x;
    		cin>>c>>m>>x;
    		if(c==0||m==0)
    		{
    			cout<<0<<endl;
    			continue;
    		}
    		int minn=min(min(c,m),x);
    		if(minn==x)
    		{ 
    			int min1=min(c-x,m-x);
    			int ans=minn+min(((c-x)+(m-x))/3,min1);
    			cout<<ans<<endl;
    		}
    		else
    		{
    			cout<<minn<<endl;
    		}
    	}
    	return 0;
    }

D. Make The Fence Great Again

题意：给n个木块的起始高度，还有每个木块加一高度的代价，求使每个木块相邻两边高度不同的最小代价。

思路：设f[i][j]，表示判断到第i个木块，第i个木块增高j所需的最小代价，可知，每个木块因为相邻两个木块，所以每个木块只需要增高0，1，2这三种可能，做法就是相当于暴力枚举加记忆化了。

#include<bits/stdc++.h>
#define ll long long
#define N 0x3f3f3f3f3f3f3f // 需要开大点 
using namespace std;
ll a[300010],v[300010];
ll f[300010][3];
int main()
{
	int t;
	scanf("%d",&t);
	//cin>>t;
	while(t--)
	{
		int n;
		cin>>n;
		for(int i=1;i<=n;i++)
		{
			scanf("%lld%lld",&a[i],&v[i]);
		}
		for(int i=1;i<=n;i++)
		{
			for(int j=0;j<3;j++)
			{
				f[i][j]=N;
			}
		}
		f[1][0]=0;
		f[1][1]=1ll*v[1];
		f[1][2]=1ll*2*v[1];
		for(int i=2;i<=n;i++)
		{
			for(int j=0;j<3;j++)
			{
				for(int k=0;k<3;k++)
				{
					if(a[i-1]+j!=a[i]+k)
					{
						f[i][k]=min(f[i][k],f[i-1][j]+k*v[i]);
					}
				}
			}
		}
		printf("%lld\n",min(f[n][0],min(f[n][1],f[n][2])));
	}
	return 0;
}

E.Game With String

题意：
给出一个01序列，两个人来玩博弈游戏，博弈规则如下：

A为先手，B为后手，给出a,b,b<a，A能够将a个连续的a个0变为1；B能够将连续的b个0变为1。
当有一个人无法操作时，则输掉这场游戏。

现给出长度不超过10^5的序列，问谁胜谁负。

思路：
感觉很有意思的一道博弈题，跟平时遇到的博弈题不一样。感觉不一样就在于游戏规则对于双方来说都不一样，好像是非平衡博弈？
首先有一个很重要的观察：

如果存在一段连续的0的长度x满足：b≤x<a，那么B必胜。

证明 B会比A多一次机会。 A能搞的B也能搞；若出现一个局面，B必须用掉这一次机会，那么说明其它位置肯定不存在一段长度大于等于b了，自然之后A不能再搞了。那么现在考虑，在什么样的局面下，B能够构造出上述观察。思考可以发现，当存在两段连续0的个数都大于等于2b时，B必然可以构造出这样一段，当然原来就有这么一段就不说了。
发现剩下的情况个数很少，我们直接分类讨论：

当不存在任何一个段长度大于等于2b时，显然此时所有合法段的长度都是不小于a的（前面的情况已经排除）。那么此时的胜负就根据合法段的奇偶个数。
当仅存在一个时，既然只有一段，直接枚举A在该段上的所有选择，看看存不存在必胜状态就行啦。A开始必然在这段区间上面选，不然B可以随便构造出满足“观察”的段。来自博主

#include<bits/stdc++.h>
using namespace std;
void A()
{
	cout<<"YES"<<endl;
}
void B()
{
	cout<<"NO"<<endl;
}
int main()
{
	int t;
	cin>>t;
	while(t--)
	{
		vector<int>v;
		int a,b;
		cin>>a>>b;
		string s;
		cin>>s;
		int cnt=0;
		for(int i=0;i<s.size();i++)
		{
			if(s[i]=='.')
			{
				cnt++;
			}
			else
			{
				if(cnt)
				{
					v.push_back(cnt);
					cnt=0;
				}
			}
		}
		if(cnt)
		{
			v.push_back(cnt);
			cnt=0;
		}
		int f=0;
		int len;
		for(int i=0;i<v.size();i++)
		{
			if(v[i]>=2*b)
			cnt++,len=v[i];
			if(v[i]>=b&&v[i]<a)
			{
				f=1;
			} 
		}
		if(f||cnt>=2)
		{
			B();
			continue;
		}
		if(cnt==0)
		{
			for(int i=0;i<v.size();i++)
			{
				if(v[i]>=a)++cnt;
			}
			if(cnt&1)
			A();
			else
			B();
			continue;
		}
		cnt=0;
		for(int i=0;i<v.size();i++)
		{
			if(v[i]>=a&&v[i]!=len)
			{
				cnt++;
			}
		}
		int flag=0;
		for(int l=1;l+a-1<=len;l++)
		{
			int r=l+a-1;
			int left=l-1,right=len-r;
			if(left>=2*b||right>=2*b)
			continue;
			if((left>=b&&left<a)||(right>=b&&right<a))
			{
				continue;
			}
			int temp=cnt+(left>=a)+(right>=a);
			if(temp%2==0)
			{
				flag=1;
				A();
				break;
			}
		}
		if(!flag)
		{
			B();
		}
	}
	return 0;
}