1.16 Codeforces Round #766 (Div. 2)

A. Not Shading

题意：

给定一个矩阵，矩阵内的元素为黑快或者白块，可以进行的操作是，选定一些黑块，然后使其的行或者列全部变成黑色的，问使r行c列的元素为黑块的操作数最少为多少？

若不可能则输出-1

思路：

1.当矩阵内的元素全为白色的时候则-1

2.若r行c列的元素本身即为黑色的，那么就是0

3.若第r行或者第c列中存在黑色的元素，那么操作数即为1

4.不满足上述条件即为2

#include <bits/stdc++.h>
using namespace std;
#define ll long long 
#define pb push_back
const int  N=2e5+5;
const int mod=1e9+7;
void solve(){
	char mp[55][55];
	int n,m;
	int x,y;
	int fg=0;
	cin>>n>>m>>x>>y;
	for(int i=1;i<=n;i++){
		for(int j=1;j<=m;j++){
			cin>>mp[i][j];
			if(mp[i][j]=='B')fg=1;
		}
	}if(mp[x][y]=='B'){
		cout<<"0\n";
		return ;
	}if(!fg){
		cout<<"-1\n";
		return ;
	}for(int i=1;i<=n;i++){
		if(mp[i][y]=='B'){
			cout<<"1\n";
			return ;
		}
	}for(int i=1;i<=m;i++){
		if(mp[x][i]=='B'){
			cout<<"1\n";
			return ;
		}
	}cout<<"2\n";
	
}
int main(){
	int t=1;
	cin>>t;
	while(t--){
		solve();
	}
}

B. Not Sitting

题意：给定一个矩阵，你可以对其中的块可以进行涂色，a不能选已经有颜色的地方，b要尽量离a远，但a会采取最优策略来使这个最远的值尽量小，问涂色数为[0,n*m-1]中a与b之间的哈密顿距离为多少。

思路：

经过分析可得，a要离b尽量的近，那么a会尽量选取中间的元素，但b要离a尽量的远，那么b会选取四个角中的一个，可以保证为距离最大。

那么，我们直接取max即可。

#include<bits/stdc++.h>
using namespace std;
#define ll long long 
#define pb push_back
const int N=2e5+5;
const int mod=1e9+7;
void solve(){
	int n,m;
	cin>>n>>m;
	vector<int> v;
	for(int i=1;i<=n;i++){
		for(int j=1;j<=m;j++){
			int d=max(max(abs(1-i)+abs(1-j),abs(n-i)+abs(1-j)),max(abs(1-i)+abs(m-j),abs(n-i)+abs(m-j)));
			v.pb(d);
		}
	}sort(v.begin(),v.end());
	for(int i=0;i<v.size();i++){
		cout<<v[i]<<" ";
	}cout<<"\n";
}
int main(){
	int t=1;
	cin>>t;
	while(t--){
		solve();
	}
}

先判断最初的中心点，然后进行bfs即可，较上述方法复杂。

#include <bits/stdc++.h>
using namespace std;
#define ll long long 
#define pb push_back
const int  N=2e5+5;
const int mod=1e9+7;
vector<int> v[N];
int n,m;
struct node{
	int x,y;
};
int d[4][2]={{0,1},{0,-1},{1,0},{-1,0}};
queue<node> q;
int ok(int x,int y){
	if(x>=1&&x<=n&&y>=1&&y<=m&&v[x][y]==0){
		return 1;
	}return 0;
}
void bfs(){
	while(!q.empty()){
		node k=q.front();
		cout<<v[k.x][k.y]<<" ";
		q.pop();
		for(int i=0;i<4;i++){
			int kx=k.x+d[i][0],ky=k.y+d[i][1];
			if(ok(kx,ky)){
				v[kx][ky]=v[k.x][k.y]+1;
				q.push(node{kx,ky});
			}
		}
	}cout<<"\n";
}
void solve(){
	cin>>n>>m;
	for(int i=1;i<=n;i++){
		v[i].clear();
		v[i].pb(0);
		for(int j=1;j<=m;j++){
			v[i].pb(0);
		}
	}int k=n/2+m/2;
	if(n%2){
		if(m%2)v[n/2+1][m/2+1]=k;
		else v[n/2+1][m/2]=v[n/2+1][m/2+1]=k;
	}else{
		if(m%2)v[n/2][m/2+1]=v[n/2+1][m/2+1]=k;
		else v[n/2][m/2]=v[n/2+1][m/2]=v[n/2][m/2+1]=v[n/2+1][m/2+1]=k;
	}
	for(int i=1;i<=n;i++){
		for(int j=1;j<=m;j++){
			if(v[i][j]==k)q.push(node{i,j});
		}
	}bfs();
}
int main(){
	int t=1;
	cin>>t;
	while(t--){
		solve();
	}
}

C. Not Assigning

题意：

给定一棵树，然后让你给其边赋权值，使之成为一颗质数树。

质数树的定义为：每条由一条或两条边组成的路径的权值都是质数。

思路：

对于质数而言，任意的偶数（除了2）都不是质数。

那么我们判断两个奇数相加的和就一定是偶数，也就不是质数。

那么如果一个顶点的度大于2，那么与个点相连的边就大于2，那么必定存在两个奇数相加的情况，也就不满足质数树的定义了。因此我们对于树的边进行赋值即赋值2 3，保证符合题意。

因此题目只要能存在答案，那么这个树的形态就一定是一条链。

1.存在度数大于2的点，直接输出-1

2.找到一个度为1的点，然后往下dfs，进行0 1染色。

最后对于输出答案的处理，我们可以存边的时候顺便存序号，然后对ans数组进行0 1 赋值，最后输出 2 或3 即可。

#include <bits/stdc++.h>
using namespace std;
#define ll long long 
#define pb push_back
const int  N=2e5+5;
const int mod=1e9+7;
int in[N];
struct node{
	int to;
	int num;
};
int k=1;
vector<node> mp[N];
int ans[N];
void dfs(int p,int fa){
	for(int i=0;i<mp[p].size();i++){
		int to=mp[p][i].to;
		int pos=mp[p][i].num; 
		if(to!=fa){
			ans[pos]=k^1;
			k=k^1;
			dfs(to,p);
		}
	}
}
void solve(){
	int n;
	cin>>n;
	for(int i=1;i<=n;i++){
		in[i]=0;
		mp[i].clear();
	}for(int i=1;i<n;i++){
		int u,v;
		cin>>u>>v;
		in[u]++;
		in[v]++;
		mp[u].pb(node{v,i});
		mp[v].pb(node{u,i});
	}int fg=0,p;
	for(int i=1;i<=n;i++){
		if(in[i]>2){
			fg=1;break;
		}if(in[i]==1){
			p=i;
		}
	}if(fg){
		cout<<"-1\n";
		return ;
	}dfs(p,0);
	for(int i=1;i<n;i++){
		if(ans[i]==0)cout<<"2 ";
		else cout<<"3 ";
	}cout<<"\n";
}
int main(){
	int t=1;
	cin>>t;
	while(t--){
		solve();
	}
}

D. Not Adding

题意：

给定一个序列，可以进行的操作为选取两个数a,b，若gcd(a,b)在序列中没有出现过，那么将gcd(a,b)加入序列中，问最多操作几次。

思路：

若数x在数列中没有出现过，那么枚举x的倍数，如果出现过，那么就将该数/x后取gcd，最后得出的gcd=1，则表示，该数可以通过该操作得到。

理由为，gcd表示两个或多个数之间有这个公共的因子，那么先将这个数/x，表示将这个数的因子中的x除去，然后看剩下的因子之间各个数还有没有公共的因子，如果存在，那么表示gcd就不会是这个数x。

那么我们倒序枚举1e6->1的每个数，然后当这个数没有出现过的时候，枚举其倍数，记录gcd，最后gcd=1，则ans++，由于是倒序枚举，那么枚举的每一个数不会影响到之前已经枚举过的数。

#include<bits/stdc++.h>
using namespace std;
#define pb push_back
#define ll long long
const int N = 1e6+5;
int a[N];
int main(){
	int n;
	cin>>n;
	for(int i=1;i<=n;i++){
		int x;
		cin>>x;a[x]=1;
	}
	int ans=0;
	for(int i=N-1;i>=1;i--){
		if(!a[i]){
			int g=0;
			for(int j=i+i;j<N;j+=i){
				if(a[j])g=__gcd(j/i,g);
			}
			if(g==1)ans++;
		}
	}cout<<ans<<"\n";
	return 0;
}