Codeforces Round #744 (Div. 3：A-E1)

目录

A. Casimir's String Solitaire（思维）

B. Shifting Sort（模拟，暴力）

C. Ticks（暴力枚举）

D. Productive Meeting（贪心，优先队列）

E1. Permutation Minimization by Deque（双端队列，模拟）

---

A. Casimir's String Solitaire（思维）

题意：给你一串字符串，每次可以删除相邻的A和B或者B和C，问能不能把字符串删除完。

思路：每次删除两个，首先字符串长度为奇数肯定删除不完，其次，每次删除的必须有B，所有要想删除完B的个数肯定要占字符串长度的一半(及B的个数==A的个数+C的个数)。

原题链接：https://codeforces.com/contest/1579/problem/A

#include<iostream>
#include<string>
using namespace std;
int main(){
	int t;
	cin >> t;
	string s;
	while(t--){
		cin >> s;
		int len=s.size();
		if(len&1){
			cout << "NO" << endl;   //长度为奇数 
			continue;
		}
		int sum=0;
		for(int i=0;i<len;i++){
			if(s[i]=='B') sum++;
		}
		if(sum==len/2) cout << "YES" << endl;   //B的个数等于字符串长度的一半 
		else cout << "NO" << endl;
	}
	return 0;
} 

B. Shifting Sort（模拟，暴力）

题意：给你一个序列，每次你可以选择一个区间和在这个区间内移动的次数 ，区间最后的数移动到区间开头，问可能的操作次数，最后使得序列递增，操作次数不能大于n，否则是无效的。

思路：首先用一个b数组存排好序的序列，依次从后往前找排好序的b[x]在a中的位置，然后把这个数移动到我们排好序的a的末尾，左端点为x，右端点为i，长度为i-x，这样我们肯定能在n次内排好序。

原题链接：https://codeforces.com/contest/1579/problem/B

#include<iostream>
#include<algorithm>
#include<queue>
using namespace std;
const int maxn=1e3;
int a[maxn],b[maxn];   //a原数组，b排好序的数组 
int main(){
	int t;
	cin >> t;
	int n;
	while(t--){
		cin >> n;
		for(int i=1;i<=n;i++){
			cin >> a[i];
			b[i]=a[i];
		}
		sort(b+1,b+n+1);
		int l[100],r[100],cnt=0;    //l左端点，r右端点，cnt表示操作的次数 
		int x=1;    //从b的第一个开始 
		while(x<n){   //指向n-1次 
			if(a[x]==b[x]){   //如果当前位置相同表示已经有序，不用找 
				x++;
				continue;
			}
			for(int i=n;i>x;i--){   //否则从前往后找b[x]在啊中的位置 
				if(b[x]==a[i]){   //找到后纪律左端点x和右端点i 
					l[cnt]=x;
					r[cnt]=i;
					cnt++;
					for(int j=i;j>x;j--){   //从这个位置到x+1把前面的往后移，表示把a[i]放到前端去 
						a[j]=a[j-1];
					}
					break;
				}
			}
			x++;    //找下一个 
		}
		cout << cnt << endl;    //输出次数 
		for(int i=0;i<cnt;i++){
			cout << l[i] << " " << r[i] << " " << r[i]-l[i] << endl;   //输出左右端点和长度 
		}
	}
	return 0;
} 

C. Ticks（暴力枚举）

 题意：有一个矩阵，有一些点是涂了颜色的标记为'*'，问你由这些涂了颜色的点能不能构成V，并且V的高度要大于等于给定的高度k，形成的V可以是多个，但必须包含说要涂了颜色的点。

思路：每遇到一个*，判断由这个*号为中心点能不够构成满足要求的V，满足要求则把这个V所经过的点标记，遍历完之后判断是否还有没标记的*号说明不能全部构成。

原题链接：https://codeforces.com/contest/1579/problem/C​​​​​​

 

 

#include<iostream>
#include<algorithm>
#include<string.h>
using namespace std;
const int maxn=1e3;
int vis[maxn][maxn];    //用来标记形成的满足要求的V 
char map[maxn][maxn]; 
void solve(int xi,int xj,int n,int m,int k){    //坐标和边界 

	int l_d=0;   //V左端的高度 
	for(int i=xi-1,j=xj-1;i>=0&&j>=0;i--,j--){   //找V左端能到达的高度 
		if(map[i][j]=='*') l_d++;
		else break;
	}

	int r_d=0;   //V右端的高度 
	for(int i=xi-1,j=xj+1;i>=0&&j<m;i--,j++){   //找V右端能到达的高度 
		if(map[i][j]=='*') r_d++;
		else break;
	}
	
	int hight=min(l_d,r_d);    //形成的V肯定是对称的，所以取最小的高度 
	if(hight<k) return;       //如果形成的V不满足给定的高度，则直接返回 
	
	for(int i=xi,j=xj,z=0;z<=hight;i--,j--,z++){   //标记满足要求的V的左端 
		vis[i][j]=1;
	}
	for(int i=xi,j=xj,z=0;z<=hight;i--,j++,z++){   //标记满足要求的V的右端 
		vis[i][j]=1;
	}
}
int main(){
	int t;
	cin >> t;
	int n,m,k;
	while(t--){
		cin >> n >> m >> k;
		memset(vis,0,sizeof(vis));
		for(int i=0;i<n;i++){
			for(int j=0;j<m;j++){
				cin >> map[i][j];
			}
		}
		for(int i=0;i<n;i++){
			for(int j=0;j<m;j++){
				if(map[i][j]=='*'){
					solve(i,j,n,m,k);     //找由这个点形成的V 
				}
			}
		}
		int flog=0;
		for(int i=0;i<n;i++){
			for(int j=0;j<m;j++){
				if(map[i][j]=='*'&&vis[i][j]==0){   //如果当前为*且没有在满足要求的V里面说明不能全部形成 
					flog=1;
					break;
				}
			}
			if(flog) break;
		}
		if(flog) cout << "NO" << endl;
		else cout <<"YES" << endl;
	}
	return 0;
} 

D. Productive Meeting（贪心，优先队列）

题意：有n个人，每个人有可以谈话的次数a[i]，当这个人的谈话次数等于0则不能再谈话，问所有人能谈话的两个人能谈话的次数最多是多少。

思路：对谈话次数进行排序，每次取剩余谈话次数最多的两个人交谈，两个人的谈话次数都减一再压入优先队列，直到队列中还剩一个人的时候。

原题链接：https://codeforces.com/contest/1579/problem/D

#include<iostream>
#include<algorithm>
#include<queue>
#include<vector>
#include<utility>
using namespace std;
typedef pair<int,int> pii;
int main(){
	int t;
	cin >> t;
	vector<pii> ans;    //用来存最后的答案 
	while(t--){
		int n,x;
		ans.clear();   //每次先清除 
		priority_queue<pii> q;    //优先队列对次数贪心 
		cin >> n;
		for(int i=1;i<=n;i++){
			cin >> x;
			pii a(x,i);   //first存谈话次数，second存下标 
			if(x>0) q.push(a);    //这个人有可以谈话的次数，入队 
		}
		while(q.size()>1){    //当至少存在两个人时
			pii a=q.top();q.pop();    //谈话次数最多的 
			pii b=q.top();q.pop();    //谈话次数次多的 
			pii nx(a.second,b.second);   
			ans.push_back(nx);	//把下标压入到vector中 
			a.first--;      //两个人的谈话次数都减一 
			b.first--;
			if(a.first) q.push(a);   //如果还有谈话次数则再次压入队列 
			if(b.first) q.push(b);
		}
		cout << ans.size() << endl; 
		for(int i=0;i<ans.size();i++){
			cout << ans[i].first << " " << ans[i].second << endl;
		}
	}
	return 0;
} 

E1. Permutation Minimization by Deque（双端队列，模拟）

题意：给你一个序列，按照顺序依次加入另一个序列中，可以往前加，也可以往后加，最后形成的新序列要字典序最小。

思路：就用双端队列模拟就可以，待放入的值小于队头的值，则放在队头，否则放在队尾。

原题链接：https://codeforces.com/contest/1579/problem/E1

#include<iostream>
#include<algorithm>
#include<deque>
using namespace std;
int main(){
	int t;
	cin >> t;
	int n,x;
	deque<int> q;
	while(t--){	
		cin >> n;
		for(int i=0;i<n;i++){
			cin >> x;
			if(q.empty()) q.push_front(x);   //第一次加入队列 
			else{
				int front=q.front();    //保存队头的值 
				if(x<front){     //比队头小则插在队头 
					q.push_front(x);
				} 
				else q.push_back(x);  //否则插入队尾 
			}
		}
		while(!q.empty()){    //输出 
			cout << q.front() << " ";
			q.pop_front();
		}
		cout << endl;
	}
	return 0;
}