Educational Codeforces Round 129 (Rated for Div. 2)(A-D)

A Game with Cards

大意：

博弈论，两个人玩牌，给出两个人的牌的个数和牌的大小， 两人交替出牌第二次出牌要严格大于第一次，问两个人分别先手必赢的是谁

思路：

很容易看出最大的那张牌决定了最终的输赢，有最大的牌的那个人先后手都必赢，而两个人最大手牌一样大，谁先手谁赢。

#include<bits/stdc++.h>
using namespace std;

int t;

int n,m;
int a,b;
int max1,max2;

int main()
{
	scanf("%d",&t);
	while(t--)
	{
		max1=max2=0;
		scanf("%d",&n);
		while(n--)
		{
			scanf("%d",&a);
			max1=max(max1,a);//alice最大
		}
		scanf("%d",&m);
		while(m--)
		{
			scanf("%d",&b);
			max2=max(max2,b);//bob最大
		}
		if(max1==max2)
		{
			puts("Alice");
			puts("Bob");
		}
		else
		if(max1>max2)
		{
			puts("Alice");
			puts("Alice");
		}
		else
		{
			puts("Bob");
			puts("Bob");	
		}
		
	}
}

B Card Trick

大意：

给出 n 张牌， m 次操作，每次操作把牌堆上面的 k 张 牌拿到牌堆下面，求每次操作完牌堆最上面的一张牌是什么

思路

不必真的用数组模拟这个过程，我们只要求出总共拿了几张即可，总共有五张牌，拿了一张，那顶端就是第二张，拿了21张，顶端还是第二张，所以我们还要做一个取余操作

#include<bits/stdc++.h>
using namespace std;

int t;

typedef long long ll;
const int N = 2e5+10;
int n,m,k;
int a[N];
ll sum;

int main()
{
	scanf("%d",&t);
	while(t--)
	{
		sum=0;
		scanf("%d",&n);
		for(int i=1;i<=n;i++) scanf("%d",&a[i]);
		scanf("%d",&m);
		for(int i=1;i<=m;i++) scanf("%d",&k),sum+=k;//求和
		sum%=n;//取余
		printf("%d\n",a[sum+1]);//输出拿的张数的下一张	
	}
}

C Double Sort

大意：

给出两个数组，数组元素个数相同，给出一种操作，可以交换这两个数组任意两列，也就是两个数组里相同位置的元素要绑定交换，问两个数组能否同时非降序有序，能的话输出操作次数并给出任意一种交换过程，不能的话输出 -1

思路：

利用结构体，把下标相同的元素放在一起，然后按第一个数组的元素大小升序排序，判断此时第二个数组元素是否非降序有序即可，这样就能判断出 -1 的情况，而模拟交换元素的方法就是把每一列原来的位置记下来，排序后模拟把位置归回原位的过程即可，如果每一个元素位置都与原来位置不同最多交换 100 次 ，不会达到 1e4 次

模拟一下交换过程

原数组

a:  2 3 1 2
b:  2 3 2 3
id: 1 2 3 4

排序后

a:  1 2 2 3
b:  2 2 3 3
id: 3 1 4 2

第一次归位我们发现第一个位置 的 id 是 3，我们要把 它和原来这里的 id 1 进行交换，先记录下来 3 和 1 再从排序后的数组种 找到 id 为 1 的列进行交换即可

第一次归位 交换 3 与 1

id: 1 3 4 2

第二次归位交换 3 与 2

id: 1 2 4 3

第三次归位交换 3 与 4

id: 1 2 3 4

第四次交换 4 与 4 相同不进行交换
模拟结束

数据给的比较小而且时间给了 2s 所以直接暴力交换

#include<bits/stdc++.h>
using namespace std;

const int N = 100+10;
const int p = 1e5+10;

struct node{
	int x;
	int y;
	int id;
}a[N];

int b[p];

bool cmp(node a,node b)
{
	return a.x<b.x||(a.x==b.x&&a.y<b.y);
}

int t,n,cnt;

//判断第二个数组是否非降序排序
bool judge()
{
	for(int i=2;i<=n;i++)
	{
		if(a[i].y<a[i-1].y) return 0;
	}
	return 1;
}

//归位处理
void check(int i)
{
	++cnt;//先记下操作数
	b[cnt*2-1]=a[i].id;
	b[cnt*2]=i;//把目标位置和所在位置记下来
	
	for(int j=1;j<=n;j++)
	{
		if(a[j].id==i)
		{
			
			a[j].id=a[i].id;
			a[i].id=i;
			return ;
		}//在排序后的数组中找到要交换的下标，完成交换
	}
}


int main()
{
	scanf("%d",&t);
	while(t--)
	{
		cnt=0;
		scanf("%d",&n);
		for(int i=1;i<=n;i++) scanf("%d",&a[i].x);
		for(int i=1;i<=n;i++)
		{
			scanf("%d",&a[i].y);
			a[i].id=i;
		}
		sort(a+1,a+1+n,cmp);//结构体排序
		
		if(!judge()) puts("-1");
		else
		{
			for(int i=1;i<=n;i++)
			{
				if(a[i].id==i) continue;//如果排序后位置与排序前相同不动
				else
				{
					check(i);//否则进行归位处理
				}
			}
			cout<<cnt<<endl;
			for(int i=1;i<=cnt*2;i+=2)
			{
				printf("%d %d\n",b[i],b[i+1]);
			}
		}
		
	}
}

D Required Length

大意：

给出一个 n 一个 x 给出一种操作可以选择 x 中的一个数 y 把 x 变成 x*y，问最少需要多少次操作可以使 x 这个数 的长度 ≥ n

思路：

一开始用的贪心，每次去乘里面最大的数，但是贪心是不正确的

13 42

这组用贪心做是13 ，但答案是 12；
正确的思路是搜索，去搜所有情况，找出第一个到达规定长度所需要的最小操作次数 n 的长度为$[2,19]$,所以没必要去用高精，long long 即可，这里我们选择用 bfs 去实现搜索，用一个map去记录操作次数

还有 -1 的情况，如果给出的数里只含有 0 或者 1，那既是 -1 的情况

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;

ll n,x;
queue<ll>qu;
map<ll,int>mp;

//判断 -1 的情况
bool judge()
{
	ll k=x;
	while(k)
	{
		int ks=k%10;
		if(ks!=0&&ks!=1) return 0;
		k/=10;
	}
	return 1;
}

int main()
{
	cin>>n>>x;
	
	if(judge())
	{
		cout<<"-1";
		return 0;
	}
	
	qu.push(x);
	mp[x]=0;
	
	//bfs
	while(!qu.empty())
	{
		ll k=qu.front();
		qu.pop();
		
		string s="";
		
		ll ks=k;
		
		//因为要判断数位，所以把数字都放到字符串里方便判断串长
		while(ks)
		{
			s+=ks%10+'0';
			ks/=10;
		}
		
		if(s.size()>=n)
		{
			cout<<mp[k];
			return 0;
		}
		
		for(int i=0;i<(int)s.size();i++)
		{
			int a=s[i]-'0';
			//重复的数不记录，只记录每个数最早完成即最小的操作数
			//这里不记录重复的另一个很重要的意义是剪枝，因为数位长起来后一定会出现很多重复的数，没必要去处理重复的数，每一个重复的数消耗的时间都是巨大的
			if(mp.find(a*k)==mp.end())
			{
				mp[a*k]=mp[k]+1;
				qu.push(a*k);
			}
		}
		
		
	}
}