2024-09-23-ABC372

ABC372

A - delete .

给一个字符串，请你删除里面所有的点。

1、循环，遇到点不输出

#include<bits/stdc++.h>
using namespace std;
int main()
{
	string s;
	cin>>s;
	for(int i=0;i<s.size();i++)
	if(s[i]!='.') cout<<s[i];
	return 0;
}

2、利用erase和remove函数删除点。

#include<bits/stdc++.h>
using namespace std;
int main()
{
	string s;
	cin>>s;
	s.erase(remove(s.begin(),s.end(),'.'),s.end());
	cout<<s;
	return 0;
}

B - 3^A

给定一个数，请你把这个数变成若干个3的次幂的和。

其实就是把这个数转化成三进制数，比如100转成三进制数是10201，那么就是要1个3的4次方，2个3的平方，1个3的0次方。

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

int main() {
	int m;
	cin >> m;
	vector<int> ans;
	for (int i = 0; i <= 10; ++i) {
		int cnt = m % 3;
		while (cnt--) {
			ans.push_back(i);
		}
		m /= 3;
	}
	cout << ans.size() << '\n';
	for (auto i : ans)
		cout << i << " ";
	cout << '\n';
	
	return 0;
}

C - Count ABC Again

每次操作改变一个字母，问每次改变后字符串里有多少个abc。

改一个字母其实只会影响到包含这个字母的三个小串是不是abc，每次根据这三个小串是否变成了abc修改一下答案就可以了。

#include <bits/stdc++.h>
using namespace std;
int n;
string s;
bool in_range(int i) {
	return i >= 0 && i < n;
}
bool check(int x) {
	for (int i = 0; i < 3; ++i)
		if (!in_range(x + i) || s[x + i] != 'A' + i)
			return false;
	return true;
}
int main() {
	int n, q;
	string s;
	cin >> n >> q >> s;
	int ans = 0;
	for (int i = 0; i < n; ++i) {
		ans += check(i);
	}
	while (q--) {
		int x;
		string c;
		cin >> x >> c;
		--x;
		for (int i = x - 2; i <= x; ++i) {
			ans -= check(i);
		}
		s[x] = c[0];
		for (int i = x - 2; i <= x; ++i) {
			ans += check(i);
		}
		cout << ans << '\n';
	}
	return 0;
}

D - Buildings

有N个楼，楼的高度是H数组，问对于每一个楼i，他右边有多少个楼j，在i和j之间没有比j更高的楼。

比如说第一个样例中，2后的合法楼为1、4、5，这几个楼构成的序列满足的性质是，他们要递增，并且两两之间没有比两者更高的楼，我们要对于每一栋楼都求出这个序列，可以使用单调栈解决，单调栈从顶到底递增，每一个数字就是楼的高度，用单调栈维护这个递增序列。

从后往前遍历，遇到一个楼的时候，此时栈的大小就是这个楼的答案，然后这个楼要入栈，我们考虑怎么更新这个栈能让他满足加粗条件：

1、如果他比栈顶小，直接入栈即可。

2、如果他比栈顶大，那么就要弹出栈顶，并继续比较，直到他比栈顶小才能入栈。

我们这样做显然保证了加粗的条件，我们弹出的那些数字都是小于当前数字并且小于下一个栈顶的，也就解决了这道题。

#include<bits/stdc++.h>
using namespace std;
const int maxn=200005;
int a[maxn],ans[maxn];
int main()
{
	int n;
	cin>>n;
	for(int i=0;i<n;i++)
		cin>>a[i];
	stack<int> s;
	for(int i=n-1;i>=0;i--)
	{
		ans[i]=s.size();
		while(!s.empty() && s.top()<a[i]) s.pop();
		s.push(a[i]);
	}
	for(int i=0;i<n;i++)
		cout<<ans[i]<<" ";
	return 0;
}

E - K-th Largest Connected Components

有N个点和Q次操作，第一种操作给定两个点，把两点连在一起，第二种操作给定v和k，问v所在的连通块中点的编号为第k大的点是谁。

首先对于连通块的维护，我们肯定使用并查集，注意到k不超过10，那么我们可以维护一个带权并查集，每个集合绑定一个这个集合的前十大的点的优先队列（或数组，或set，时间在这里卡的不紧），然后在合并的时候将两个集合一共二十个点挑出前十大即可。

#include<bits/stdc++.h>
using namespace std;
const int maxn=200005;
int fa[maxn];
priority_queue<int> q[maxn];
int ans[maxn][20];
int findfa(int x)
{
	if(x==fa[x]) return x;
	else return fa[x]=findfa(fa[x]);
}
void unio(int x,int y)
{
	int fx=findfa(x),fy=findfa(y);
	if(fx==fy) return;
	fa[fx]=fy;
	priority_queue<int> tmp;
	while(!q[fx].empty()) {
		q[fy].push(q[fx].top());
		q[fx].pop();
	}
	int k=0;
	while((k<10) && (!q[fy].empty())) {
		ans[fy][k++]=q[fy].top();
		tmp.push(q[fy].top());
		q[fy].pop();
	}
	swap(q[fy],tmp);
}
int main()
{
	int n,Q;
	cin>>n>>Q;
	for(int i=0;i<n;i++) {
		fa[i+1]=i+1;
		q[i+1].push(i+1);
		ans[i+1][0]=i+1;
	}
	while(Q--)
	{
		int c,x,y;
		cin>>c>>x>>y;
		if(c==1) unio(x,y);
		else {
			int f=findfa(x);
			if(y<=(int)(q[f].size()))
				cout<<ans[f][y-1]<<endl;
			else puts("-1");
		}
	}
	return 0;
}