Codeforces Round #777 (Div. 2)

挺有意思的一场比赛，T2最优解法属实没想到，T4少考虑了一种情况，蓝名差点掉没了

B.Madoka and the Elegant Gift

题目大意：给定一个01矩阵，判断其所有1的连通块是否都是完整矩形。
分析：我的想法是求出每个1的连通块所属的最小矩形，然后判断这个矩形是不是全1矩形，这样确实没毛病，但是貌似有些麻烦，下面看正解，只需要判断矩形中每个2*2小矩形中1的个数是否为3即可。

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define pii pair<int,int>
const int mod=1e9+7;
const int INF=0x3f3f3f3f;
const int N=110;
string s[N];
int main(){
	ios::sync_with_stdio(false);
	cin.tie(0),cout.tie(0);
	int t;
	cin>>t;
	while (t--){
		int n,m;
		cin>>n>>m;
		for (int i=0;i<n;i++) cin>>s[i];
		int flag=1;
		for (int i=0;i<n-1;i++){
			for (int j=0;j<m-1;j++){
				int cnt=s[i][j]-'0'+s[i][j+1]-'0'+s[i+1][j]-'0'+s[i+1][j+1]-'0';				
				if (cnt==3) flag=0;
			}
		}
		if (flag) cout<<"YES\n";
		else cout<<"NO\n";
	}	
	return 0;
} 

C.Madoka and Childish Pranks

题目大意：给定一个目标矩阵，然后判断是否可以通过染色操作得到目标矩阵，并构造方案，染色操作为：选取一个矩形，左上角染白色然后黑白相间染。
分析：容易发现左上角的那一格是无论如何也不可能染上黑色的，然后我们只需要选取1 * 2和2 * 1两种规格的矩形染色即可，方法就是通过1 * 2矩形用左边的列去染右边的列，再用2 * 1的矩形用左上角的格子染第一列。

#include<iostream>
#include<cstring>
#include<cstdio>
#include<vector>
#include<algorithm>
#include<map>
#include<cmath>
#include<queue>
#define clean(x) memset(x,0,sizeof(x))
#define maxn 1000005
using namespace std;

int read()
{
	int x=1,res=0;
	char c=getchar();
	while(c<'0'||c>'9')
	{
		if(c=='-')
		x=-1;
		c=getchar();
	}
	while(c>='0'&&c<='9')
	{
		res=res*10+(c-'0');
		c=getchar();
	}
	return res*x;
}
struct node{
	int a,b,c,d;
}ans[maxn];
int f[105][105],cnt;
char a[105];
void solve()
{
	int n=read();int m=read();cnt=0;
	for(int i=1;i<=n;i++){
		cin>>(a+1);
		for(int j=1;j<=m;j++)
		f[i][j]=a[j]-'0';
	}
	if(f[1][1]==1){
		puts("-1");
		return;
	}
	for(int i=1;i<=n;i++)
	for(int j=m;j>=2;j--)
	{
		if(f[i][j]==1){
			ans[++cnt]=(node){i,j-1,i,j};
		}
	}
	for(int i=n;i>=2;i--){
		if(f[i][1]){
			ans[++cnt]=(node){i-1,1,i,1};
		}
	}
	printf("%d\n",cnt);
	for(int i=1;i<=cnt;i++){
		printf("%d %d %d %d\n",ans[i].a,ans[i].b,ans[i].c,ans[i].d);
	}
}

int main()
{
	int t=read();
	while(t--)
	solve();
	return 0;
}

D. Madoka and the Best School in Russia

这题确实有点可惜了。
题目大意：判断一个数是否能被拆分为两种及以上beautiful数的乘积。
A number is called good if it is a multiple of d
A number is called beatiful if it is good and it cannot be represented as a product of two good numbers.
分析：容易看出如果一个数是beautiful数那么它一定能被d整除且不能被d²整除，因此它只能含有一个d因子，然后分情况讨论(记余数为a即 $x\%d=a$)：
$$\begin{gathered} 1.x中含有两个及以上d因子且a为合数 \\ 2.x中含有三个d因子，a为质数，x的任意一个因子和a的乘积不是d的倍数 \\ 3.x中含有四个及以上d因子，a为质数，x为合数 \end{gathered}$$
以上三种情况符合题意，其余不符合题意。

#include<iostream>
#include<cstring>
#include<cstdio>
#include<vector>
#include<algorithm>
#include<map>
#include<cmath>
#include<queue>
#define clean(x) memset(x,0,sizeof(x))
#define maxn 1000005
using namespace std;

int read()
{
	int x=1,res=0;
	char c=getchar();
	while(c<'0'||c>'9')
	{
		if(c=='-')
		x=-1;
		c=getchar();
	}
	while(c>='0'&&c<='9')
	{
		res=res*10+(c-'0');
		c=getchar();
	}
	return res*x;
}

int check(int x)
{
	for(int i=2;i*i<=x;i++)
	if(x%i==0) return 1;
	return 0;
}

void solve()
{
	int x=read(),cnt=0,d=read();
	while(x%d==0)
	{
		cnt++;
		x=x/d;
	}
	if(cnt<2){
		puts("NO");
		return;
	}
	if(check(x)){
		puts("YES");
		return;
	}
	if(check(d)==0){
		puts("NO");
		return;
	}
	if(cnt>=4){
		puts("YES");
		return;
	}
	if(cnt==3){
		for(int i=2;i*i<=d;i++)
		{
			if(d%i==0){
				if(i*x%d!=0||(d/i)*x%d!=0)
				{
					puts("YES");
					return;
				}
			}
		}	
	}
	puts("NO");
}

int main()
{
	int t=read();
	while(t--)
	solve();
	return 0;
}

E. Madoka and the Sixth-graders

题目有点繁琐，大意去看原题吧 2333
分析：首先，入度为0的结点每次一定会来一个新的学生，而入度不为0的结点不可能会来新学生，所以每一次课过后学生的最大编号会增加$cn{t}_{de[i]=0}$然后我们只需要根据目标最大编号和$cn{t}_{de[i]=0}$就能判断出一共进行了几次课（记为step）。
然后，我们需要考虑进行了step次课过后每个结点最初的学生去了哪里，由于step大小为1e9，而且每个结点只有一条路往下走，因此可以通过二进制优化（倍增）来实现。
这样我们就可以贪心考虑如何使得字典序最小，显然应该从第一位开始考虑，我们从小到大枚举结点，然后用倍增快速算出终点，显然最初的值肯定要大于等于最终的值，因为可能不止一个点会到达这个终点，由于要字典序最小，所以我们就贪心取大于等于这个数的最小值，另外对于每个终点在所有能够到达终点的起点中一定有一个数等于终点数的值，因此我们需要记录一下这些值并且其它终点的起点不可使用，这样就是一个二分查找，只需用一个set就可以实现。

#include<iostream>
#include<cstring>
#include<cstdio>
#include<vector>
#include<algorithm>
#include<map>
#include<cmath>
#include<set>
#include<queue>
#define clean(x) memset(x,0,sizeof(x))
#define maxn 100005
using namespace std;

int read()
{
	int x=1,res=0;
	char c=getchar();
	while(c<'0'||c>'9')
	{
		if(c=='-')
		x=-1;
		c=getchar();
	}
	while(c>='0'&&c<='9')
	{
		res=res*10+(c-'0');
		c=getchar();
	}
	return res*x;
}
int n,aa,cnt,maxa,step;
int de[maxn],f[maxn][35],to[maxn],vis[maxn],p[maxn];
set<int>s;
int main()
{
	n=read();
	for(int i=1;i<=n;i++)
	{
		aa=read();
		de[aa]++;
		f[i][0]=aa;
	}
	for(int i=1;i<=30;i++){
		for(int j=1;j<=n;j++){
			f[j][i]=f[f[j][i-1]][i-1];
		}
	}
	for(int i=1;i<=n;i++){
		if(de[i]==0) cnt++;
	}
	for(int i=1;i<=n;i++){
		aa=read();p[i]=aa;
		if(aa<=n) vis[aa]=1;
		maxa=max(maxa,aa);
	}
	for(int i=1;i<=n;i++){
		if(!vis[i]) s.insert(i);
		vis[i]=0;
	}
	step=(maxa-n)/cnt;
	for(int i=1;i<=n;i++){
		int x=i;
		for(int j=0;j<=30;j++){
			if(step&(1<<j))
			x=f[x][j];
		}
//		cout<<x<<" ";
		if(!vis[p[x]]){
			printf("%d ",p[x]);
			vis[p[x]]=1;
		}else{
			int y=*s.lower_bound(p[x]);
			s.erase(y);
			printf("%d ",y);
		}
	}
	return 0;
}