Codeforces Round #818 (Div. 2)

A. Madoka and Strange Thoughts

题目链接：Problem - A - Codeforces

样例输入：

6
1
2
3
4
5
100000000

样例输出：

1
4
7
10
11
266666666

题意：求满足1<=a,b<=n且lcm(a,b)/gcd(a,b)<=3的(a,b)的个数

分析：由a*b=lcm(a,b)*gcd(a,b)可知lcm(a,b)/gcd(a,b)=a/gcd(a,b)*b/gcd(a,b)

由于a/gcd(a,b)和b/gcd(a,b)都是整数，那么对于小于等于3的乘积情况无非就1*1，1*2，1*3，2*1，3*1五种情况，而且1*2和2*1这样的还是对称的，先来看看1*1的情况，因为a=b=gcd(a,b)，由于a和b都是小于等于n的，这种情况显然有n种，下面来看下2*1的情况，那么就有a=2*b,b=gcd(a,b),那么显然就有n/2种情况，注意是下取整，同理3*1的情况就是n/3种情况，再考虑到对称的情况，那么总的答案就是n+(n/2+n/3)*2，注意下取整。

下面是代码：

#include<iostream>
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<cmath>
#include<vector>
#include<queue>
using namespace std;
const int N=1e5+10;
int main()
{
	int T;
	cin>>T;
	while(T--)
	{
		int n;
		scanf("%d",&n);
		printf("%d\n",n+n/2*2+n/3*2);
	}
	return 0;
} 

B. Madoka and Underground Competitions

题目链接：Problem - B - Codeforces

样例输入： 

3
3 3 3 2
2 1 1 2
6 3 4 2

样例输出：

X..
..X
.X.
XX
XX
.X..X.
X..X..
..X..X
.X..X.
X..X..
..X..X

题意：给定一个n*n的方格，我们要保证每行每列中每连续k个格中至少要有一个x，其余为.，现在告诉我们第r行c列是一个x，让我们输出一种方案使得我们填充的x数目尽量少

分析：如果我们不考虑已经填好了一个x，显然每行至少要填n/k个x，所以总共需要填n*n/k个x，而且这样显然是有一种可行方案的，也就是以k*k的方格作为基本单元只在副对角线上填x，其余位置填.即可，那么现在告诉我们已经有一个地方填过了x，那么我们其实只要构造有一种可行方案使得我们在原图的基础上再填n*n/k个x可以满足题意即可，其实我们可以在给定的那个x那一条副对角线上填x，然后将这条副对角线分别向左向右移动k个单元再次进行填x，依次类推，直至单元格填满为止，其实由于位于同一条副对角线上的单元格的x坐标加上y坐标的值是恒定不变的，而将该条对角线左移或者右移x个单位将会使得横纵坐标的和变化x，所以我们只需要把所有的满足(i+j-r-c)%k=0的单元格上填上x即可，其余位置填.，容易证明，无论一开始x的位置在哪，这样填的x的数目都是n*n/k个，这个相当于对副对角线平移，发现在n*n方格内与这些副对角线相交的方格数是不会发生变化的。

下面是代码：

#include<iostream>
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<cmath>
#include<vector>
#include<queue>
using namespace std;
int main()
{
	int T;
	cin>>T;
	while(T--)
	{
		int n,k,r,c;
		scanf("%d%d%d%d",&n,&k,&r,&c);
		for(int i=1;i<=n;i++)
		{
			for(int j=1;j<=n;j++)
			if((i+j+n*n-r-c)%k==0) printf("X");
			else printf(".");
			puts("");
		}
		puts("");
	}
	return 0;
}

C. Madoka and Formal Statement

题目链接：Problem - C - Codeforces

 样例输入：

5
3
1 2 5
1 2 5
2
2 2
1 3
4
3 4 1 2
6 4 2 5
3
2 4 1
4 5 3
5
1 2 3 4 5
6 5 6 7 6

样例输出：

YES
NO
NO
NO
YES

题意：给定一个长度为n的数组a和一个长度为n的数组b，希望我们经过以下操作将a变成b，如果可以输出YES，否则输出NO

第i个位置的元素可以+1的充分必要条件是第i+1个位置的元素值大于等于当前元素，特殊地，如果i=n，那么i+1看作1

分析：首先容易知道的一点是如果第i个数ai还没有到达其上界bi,但是第i+1个数的上界b(i+1)是小于bi-1的，那么显然第i个数不可能到达其上界，当第i个数本来就是上界那么我们就不需要额外考虑，我们可以按照这个方法判断一下是否有因为这种情况不满足的，除了这种情况还有没有其他情况也使得答案为NO呢？其实就是一开始给定的ai>bi的情况，这种情况也是我们容易忽视的一种情况，一般都下意识的默认ai<=bi，除了这两种情况还有没有其他情况呢？答案是NO，那么我们就证明一下其余情况都可以通过操作得到其上界，假如我们一开始n个数中没有一个i满足ai=bi，那么我们此时是一定可以操作的，因为这n个数相当于构成一个环，不可能每个数都比他右边的数大，所以我们一定可以操作，当某个位置pos达到其上界时，我们可以看其前面一个位置，也就是第pos-1个位置，而由于我们一开始检测的不存在一个数未达到上界且该数后面一个数的上界小于当前数上界-1，所以前一个数一定可以到达上界，按照这个方法进行构造那么一定就会使得所有的数都达到其上界，证毕

下面是代码：

#include<iostream>
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<cmath>
#include<vector>
#include<queue>
using namespace std;
const int N=2e5+10;
int a[N],b[N];
int main()
{
	int T;
	cin>>T;
	while(T--)
	{
		int n;
		scanf("%d",&n);
		for(int i=1;i<=n;i++)
			scanf("%d",&a[i]);
		for(int i=1;i<=n;i++)
			scanf("%d",&b[i]);
		bool flag=true;
		for(int i=1;i<=n;i++)
		{
			if(a[i]==b[i]) continue;
			if(b[i]>b[i%n+1]+1) flag=false; 
		}
		if(flag) puts("YES");
		else puts("NO");
	}
	return 0;
}

D. Madoka and The Corruption Scheme

题目链接：Problem - D - Codeforces

 样例输入：

3 2

样例输出：

7

题意：有2^n个选手进行比赛，编号分别为1，2，……,2^n.规则就是每回合进行两人一组的比赛，获胜的人晋级，失败的人退出比赛。所以这样的比赛一定会进行n轮，现在Madoka 希望最终胜者的编号最小，它可以决定一开始所有选手的比赛顺序以及每次比赛中谁获得胜利，他的目的是使得最后获胜的人的编号尽可能小，而现在有另外一个人拥有k次修改结果的机会，每次修改结果可以将原来Madoka规定的比赛结果翻转，也就是原来获胜的人变为失败的人，而原来失败的人变为获胜的人，这个人的目的就是通过这k次修改机会使得最后获胜的人的编号尽可能大，问在Madoka绝顶聪明的情况下（也就是尽量使得编号小的人获胜的前提下）这个编号最大是多少？

分析：这个题还是有一定思维含量的，但是想明白之后代码就变的非常简单了。我们不妨假设每次都是位于右边的人获胜，也就是尽量把编号小的人安排在右边，那么未修改前的图大概就是这样了：

 实线代表晋级，每次都是位于右边的孩子晋级，初始状态答案是1，也就是一直向右，那么从根节点到答案的路径就是RRR……R,一共n个R，从根节点到任何一个节点都唯一地对应着一条路径，不妨假设从根节点到节点x的路径是RLRRR……LR，里面一共有m个L，那么显然我们就需要至少对初始答案进行m次翻转，也就是说如果我们不进行翻转，那么得到的结果就是1，进行1次翻转可以多对应C(n,1)个节点，因为每一个位置方向发生该边后找到的节点都是完全不同的两个节点，在第一次翻转的基础上进行第二次翻转相当于在n个R中挑出两个变为L，这样又新增加C(n,2)个节点，而按照Madoka的贪心策略，显然是让你第一次翻转后得到的n个节点编号是2~n+1，两次翻转后得到的编号是n+2~n+2+C(n,2)-1，依次类推，那么经过k次翻转（k<=n），能够得到的不同的点数就是,那么Madoka肯定将节点编号最小的安排在这些点中，而另一个人肯定取这些点中的最大值，那么这个点数就是对应着答案。

下面是代码：

#include<iostream>
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<cmath>
#include<vector>
#include<queue>
using namespace std;
const int N=1e5+10,mod=1e9+7;
int fac[N],inv[N];
int C(int a,int b)
{
	return 1ll*fac[a]*inv[b]%mod*inv[a-b]%mod;
}
int qpow(int a,int b)
{
	int ans=1;
	while(b)
	{
		if(b&1) ans=1ll*ans*a%mod;
		b>>=1;
		a=1ll*a*a%mod;
	}
	return ans;
}
int main()
{
	int n,k;
	cin>>n>>k;
	fac[0]=inv[0]=1;
	for(int i=1;i<=n;i++) fac[i]=1ll*fac[i-1]*i%mod;
	inv[n]=qpow(fac[n],mod-2);
	for(int i=n-1;i>=1;i--) inv[i]=1ll*inv[i+1]*(i+1)%mod;
	int ans=0;
	k=min(n,k);//当k大于n时是无意义的，一定能使得最大编号获胜 
	for(int i=0;i<=k;i++)
		ans=(ans+C(n,i))%mod;
	printf("%d",ans);
	return 0;
}