The 2023 ICPC Asia Jinan Regional Contest (The 2nd Universal Cup. Stage 17: Jinan)

0hang

已于 2024-08-12 14:45:58 修改

阅读量507

点赞数 12

分类专栏： 23年ICPC区域赛文章标签：算法 c++ 开发语言数据结构

于 2024-08-12 14:43:06 首次发布

本文链接：https://blog.csdn.net/hanghang20030820/article/details/141086996

版权

23年ICPC区域赛专栏收录该内容

2 篇文章 0 订阅

订阅专栏

题目链接

Problem D. 最大数码

解析：
我们可以想一下如果a的范围或者b的范围在10以外，那么就肯定能凑出一个9，如果在之内直接暴力即可。

#include <bits/stdc++.h>
using namespace std;
#pragma G++ optimize(2)
#define debug(x) cout << "[debug] " #x << " = " << x << '\n';
#define double long double
#define int long long
#define xiaowen ac
typedef unsigned long long ull;
typedef long long ll;
typedef pair<int, int> PII;
const int N = 1e6 + 7;
const int mod =1e9+7;
void solved(){
	int l1,r1,l2,r2;
	cin>>l1>>r1>>l2>>r2;
	if (r1-l1+1>=10){
		cout<<"9\n";
	}else if (r2-l2+1>=10){
		cout<<"9\n";
	}else{
		int maxx=0;
		for (int i=l1;i<=r1;i++){
			for (int j=l2;j<=r2;j++){
				int x=i+j;
				while (x){
					maxx=max(x%10,maxx);
					x/=10;
				}
			}
		}
		cout<<maxx<<"\n";
	}
}
signed main() {
//	ios::sync_with_stdio(false);
//	cin.tie(nullptr), cout.tie(nullptr);
	int T;
	// T = 1;
	cin >> T;
	while (T--) {
		solved();
	}
	return 0;
}

Problem I. 奇怪的排序

这道题的n很小，时间上很充裕，但是注意操作次数不能超过(n/2)，因此我们每次选最靠左al(!=)i，最靠右的ar,al>ar，就能避免这个问题。选了之后把选中这段排序，排序之后又继续跑。

#include <bits/stdc++.h>
using namespace std;
#pragma G++ optimize(2)
#define debug(x) cout << "[debug] " #x << " = " << x << '\n';
#define double long double
#define int long long
#define xiaowen ac
typedef unsigned long long ull;
typedef long long ll;
typedef pair<int, int> PII;
const int N = 1e6 + 7;
const int mod =1e9+7;
int a[N];
void solved(){
	int n;
	cin>>n;
	for (int i=1;i<=n;i++){
		cin>>a[i];
	}
	vector<pair<int,int>>v;
	for (int i=1;i<=n;i++){
		if (a[i]>i){
			for (int j=n;j>=1;j--){
				if (a[i]>a[j]){
					v.push_back({i,j});
					sort(a+i,a+j+1);
				//	i=j-1;
					break;
				}
			}
		}
	}
	cout<<v.size()<<"\n";
	for (auto it:v){
		cout<<it.first<<" "<<it.second<<"\n";
	}
}
signed main() {
//	ios::sync_with_stdio(false);
//	cin.tie(nullptr), cout.tie(nullptr);
	int T;
	// T = 1;
	cin >> T;
	while (T--) {
		solved();
	}
	return 0;
}

A. Many Many Heads

解析：
我们可以先看什么时候只有唯一的，因为这种情况少，容易发现规律。
[([()])]这种里面一个符号里面套着另一个符号就不行。而[([()])][],这种还可以变成[([()])[]],[()]()[],这种也可以[()]()[],[()[()]],我们可以发现规律如果有相邻的()或者[]有超过3个那么就不唯一。
当然发现不了规律也可以，和队友VP时没发现这个规律，我们直接用栈模拟的，首先先把字符串变成合法的。
维护一个栈，按照顺序遍历序列中每一个括号，如果此时栈非空且栈顶的括号种类等于该括号，则弹出栈顶，否则将该种类括号压入栈。
我当时把这种有间隔的，比如下面这种，[()]，不是连续的就称为一层，二层，如图是4层
在这里插入图片描述
而像这种就是两层。

最后判断一层中是否有4个同种符号的。

第一种写法

#include <bits/stdc++.h>
using namespace std;
#pragma G++ optimize(2)
#define debug(x) cout << "[debug] " #x << " = " << x << '\n';
#define double long double
#define int long long
#define xiaowen ac
typedef unsigned long long ull;
typedef long long ll;
typedef pair<int, int> PII;
const int N = 1e4 + 7;
const int mod =1e9+7;
void solve() {
	string s;
	cin>>s;
	int cnt=0;
	for (int i=0; i<s.size(); i++) {
		if (s[i]==')')	s[i]='(';
		if (s[i]==']')	s[i]='[';
	}
	for (int i=1; i<s.size(); i++) {
		if (s[i]==s[i-1]){
			cnt++;
		}
	}
	if (cnt>=3){
		cout<<"No\n";
	}else{
		cout<<"Yes\n";
	}
}
signed main() {
	ios::sync_with_stdio(false);
	cin.tie(nullptr), cout.tie(nullptr);
	int T=1;
	// T = 1;
	cin >> T;
	while (T--) {
		solve();
	}
	return 0;
}

第二种写法

#include <bits/stdc++.h>
using namespace std;
#pragma G++ optimize(2)
#define debug(x) cout << "[debug] " #x << " = " << x << '\n';
#define double long double
#define int long long
#define xiaowen ac
typedef unsigned long long ull;
typedef long long ll;
typedef pair<int, int> PII;
const int N = 2e6 + 7;
const int mod =1e9+7;
int a[N];
int ans[N][3];
void solved() {
	string s;
	cin>>s;
	for (int i=0; i<s.size()+100; i++) {
		ans[i][0]=0;
		ans[i][1]=0;
	}
//	cout<<s<<"***\n";
	stack<char>q;
//	int cnt=0;
	for (int i=0; i<s.size(); i++) {
		if (!q.empty()) {
			//cout<<i<<" "<<q.front()<<"***\n";
			if ( s[i]=='(' || s[i]==')' ) {
				if (q.top()=='(') {
					ans[q.size()][0]++;
					q.pop();
				} else {
					q.push('(');
					ans[q.size()][0]++;
				}
			} else {
				if (q.top()=='[') {
					ans[q.size()][1]++;
					q.pop();
				} else {
					q.push('[');
					ans[q.size()][1]++;
				}
			}
		} else {
			if (s[i]=='('||s[i]==')') {
				q.push('(');
				ans[q.size()][0]++;
			} else {
				q.push('[');
				ans[q.size()][1]++;
			}
		}
	}
	for (int i=0;i<s.size();i++){
		if (ans[i][0]>=4||ans[i][1]>=4){
			cout<<"No\n";
			return;
		}
	}
	cout<<"Yes\n";
}
signed main() {
	ios::sync_with_stdio(false);
	cin.tie(nullptr), cout.tie(nullptr);
	int T;
	// T = 1;
	cin >> T;
	while (T--) {
		solved();
	}
	return 0;
}

G. Gifts from Knowledge

解析：
先从题目中提取信息。
我想通过反转使每列最多出现一个1，那么当前列和和对称列1的个数最多只有两个才能实现。
超过则输出-1
那我们再从不同情况的不同反转情况来讨论。
（1）如果两个都出现在同一列，那么一个翻，一个不翻
（2）如果一个出现在当前列，一个出现在对称列，那么两个同时翻，或者两个都不翻。
但还要想一想另外不成立的情况，如果说这一行中有一列必须反转，有一行不能反转，那么就出现矛盾，不能实现了。
最后就转换成一个互质的问题了，有联系的两行会有关系，我把有关系的行联系起来，最后看联通块的数量即可。
这道题可以用两个方法解决，二分图染色法或者值域并查集。
值域并查集：
为什么需要用值域并查集呢，因为普通的并查集只有1-n个点，但这道题有两种情况就得需要1-2n个点。
令当前列为i,对立列为i’。（i+n）表示i的反转，(i’+n)表示i’的反转
两个1都在同一列时，只需要一个反转。则连边（i,i’+n）,(i’,i+n)
两个1不在同一列时，要么反转，要么同时反转，连边(i,i’),(i+n,i’+n)
特判一下奇数列时，中间一列出现1的个数不能大于1
如果最后i和(i+n)在同一联通块则无解，这种情况就说明一行中有一列必须反转，一行不能反转。否则联通块的数量就为2c，最后答案为2^c.

#include <bits/stdc++.h>
using namespace std;
#pragma G++ optimize(2)
#define debug(x) cout << "[debug] " #x << " = " << x << '\n';
#define double long double
#define int long long
#define xiaowen ac
typedef unsigned long long ull;
typedef long long ll;
typedef pair<int, int> PII;
const int N = 2e6 + 7;
const int mod =1e9+7;
int a[N];
int fa[N];
string s[N];
int find(int x) {
	if (fa[x]==x) {
		return x;
	}
	return fa[x]=find(fa[x]);
}
void unionn(int x,int y) {
	x=find(x);
	y=find(y);
	if (x==y) {
		return;
	}
	fa[x]=y;
}
int quick_pow(int a,int b) {
	int ans=1;
	while (b) {
		if (b&1) {
			ans=ans*a%mod;
		}
		a=a*a%mod;
		b>>=1;
	}
	return ans%mod;
}
void solved() {
	int n,m;
	cin>>n>>m;
	for (int i=1; i<=2*n; i++) {
		fa[i]=i;
	}
	for (int i=1; i<=n; i++) {
		cin>>s[i];
		s[i]=' '+s[i];
	}
	vector<int>v[2*m];
	for (int i=1; i<=n; i++) {
		for (int j=1; j<=m; j++) {
			if (s[i][j]=='1') {
				v[j].push_back(i);
			}
		}
	}
	if (m&1) {
		if (v[(m+1)/2].size()>=2) {
			cout<<"0\n";
			return;
		}
	}
	for (int i=1; i<=m/2; i++) {
		int j=m-i+1;
		int ans1=v[i].size();
		int ans2=v[j].size();
		if (ans1+ans2>2) {
			cout<<"0\n";
			return;
		} else if (ans1+ans2<=1) {
			continue;
		} else {
			if (ans1&&ans2) {
				if (v[i][0]==v[j][0]) {
					continue;
				}
				unionn(v[i][0],v[j][0]);
				unionn(v[i][0]+n,v[j][0]+n);
			} else {
				if (ans1) {
					if (v[i][0]==v[i][1]) {
						continue;
					}
					unionn(v[i][0],v[i][1]+n);
					unionn(v[i][0]+n,v[i][1]);
				} else {
					if (v[j][0]==v[j][1]) {
						continue;
					}
					unionn(v[j][0],v[j][1]+n);
					unionn(v[j][0]+n,v[j][1]);
				}
			}
		}
	}
	int ans=0;
	for (int i=1; i<=n; i++) {
		if (find(i)==find(i+n)) {
//			cout<<i<<"****"<<"\n";
			cout<<"0\n";
			return;
		}

	}
	for (int i=1; i<=2*n; i++) {
		find(i);
		if (fa[i]==i) {
			ans+=1;
		}
	}
	cout<<quick_pow(2,ans/2)%mod<<"\n";
}
signed main() {
	ios::sync_with_stdio(false);
	cin.tie(nullptr), cout.tie(nullptr);
	int T;
	// T = 1;
	cin >> T;
	while (T--) {
		solved();
	}
	return 0;
}

二分图染色法：
建议可以先去B站上看一下董晓算法的二分图染色。
这个做法和上一个方法差不多，建边方法都一样。
只不过一开始让(i,i+n)建边，这样i和i+n实际上就会染成不同的颜色，但是如果(i’,i)，（i’,i+n）建边之后这样是不能实现，也就是i和i+n颜色会变成一样，那么就输出-1，最后联通块的数量就为2c，最后答案为2^c.

#include <bits/stdc++.h>
using namespace std;
#pragma G++ optimize(2)
#define debug(x) cout << "[debug] " #x << " = " << x << '\n';
#define double long double
#define int long long
#define xiaowen ac
typedef unsigned long long ull;
typedef long long ll;
typedef pair<int, int> PII;
const int N = 2e6 + 7;
const int mod =1e9+7;
multiset<int>s1,s2;
int a[N];
string s[N];
vector<int>e[N];
int vis[N];
int flag;
int qpow(int a,int b) {
	int ans=1;
	while (b) {
		if (b&1) {
			ans=ans*a%mod;
		}
		a=a*a%mod;
		b>>=1;
	}
	return ans%mod;
}
void dfs(int x,int c) {
	if (flag) {
		return;
	}
	vis[x]=c;
	for (auto v:e[x]) {
		if (!vis[v]) {
			if (x==1) {
	//			cout<<x<<" "<<v<<"\n";
			}
			dfs(v,3-c);
		} else if (vis[v]==c) {
			flag=1;
			return;
		}
	}
}
void solved() {
	int n,m;
	cin>>n>>m;
	for (int i=1; i<=2*n; i++) {
		e[i].clear();
		vis[i]=0;
	}
	for (int i=1; i<=n; i++) {
		cin>>s[i];
		s[i]=' '+s[i];
	}
	vector<int>v[2*m];
	for (int i=1; i<=n; i++) {
		for (int j=1; j<= m; j++) {
			if (s[i][j]=='1') {
				v[j].push_back(i);
			}
		}
	}
	if (m&1) {
		if (v[(m+1)/2].size()>=2) {
			cout<<"0\n";
			return;
		}
	}
	for (int i=1;i<=n;i++){
		e[i].push_back(i+n);
		e[i+n].push_back(i);
	}
	for (int i=1; i<=m/2; i++) {
		int j=m-i+1;
		int ans1=v[i].size();
		int ans2=v[j].size();
		if (ans1+ans2>2) {
			cout<<"0\n";
			return;
		} else if (ans1+ans2<=1) {
			continue;
		} else {
			int x,y;
			if (ans1==2) {
				x=v[i][0];
				y=v[i][1];
				e[x].push_back(y);
				e[y].push_back(x);
				e[x+n].push_back(y+n);
				e[y+n].push_back(x+n);
			} else if (ans2==2) {
				x=v[j][0];
				y=v[j][1];
				e[x].push_back(y);
				e[y].push_back(x);
				e[x+n].push_back(y+n);
				e[y+n].push_back(x+n);
			} else {

				x=v[i][0];
				y=v[j][0];
				if (x==y) {
					continue;
				}
				e[x].push_back(y+n);
				e[y+n].push_back(x);
				e[x+n].push_back(y);
				e[y].push_back(x+n);
			}
		}
	}
	int ans=0;
	for (int i=1; i<=2*n; i++) {
		flag=0;
		if (!vis[i]) {
			ans+=1;
			dfs(i,1);
			if (flag) {
				cout<<"0\n";
				return;
			}
		}
	}
	cout<<qpow(2,ans)<<"\n";
}
signed main() {
	ios::sync_with_stdio(false);
	cin.tie(nullptr), cout.tie(nullptr);
	int T;
	// T = 1;
	cin >> T;
	while (T--) {
		solved();
	}
	return 0;
}

K. Rainbow Subarray

解析：
要使一串数组a(i+1)-a(i)=1,也就是每一个数比前一个数多一。
那我们可以把每一个a(i)变成a(i)-i,这样a(i+1)-a(i)=1就可以变成a(i+1)-(i+1)=a(i)-i。
最后也就把这个问题转化为：将这个数组的数变为同一个数。
接下来的问题就是我们如何将一个数组变为同一个数操作次数最少。
这时取中位数操作次数最少，证明过程如下
在这里插入图片描述
然后我们用两个multiset做一个对顶堆，就像滑动窗口一样，因为涉及到插入数和删除数，multiset的操作为(logⁿ)，很符合这道题。

#include <bits/stdc++.h>
using namespace std;
#pragma G++ optimize(2)
#define debug(x) cout << "[debug] " #x << " = " << x << '\n';
#define double long double
#define int long long
#define xiaowen ac
typedef unsigned long long ull;
typedef long long ll;
typedef pair<int, int> PII;
const int N = 1e6 + 7;
const int mod =1e9+7;
multiset<int>s1,s2;
int a[N];
int n,k,sum1,sum2;
void init() {
	s1.clear();
	s2.clear();
	sum1=0;
	sum2=0;
}
void balance() {
	while (s2.size()+1>s1.size()) {
		s1.insert(*s2.begin());
		sum1+=*s2.begin();
		sum2-=*s2.begin();
		s2.erase(s2.find(*s2.begin()));
	}
	while (s1.size()>=s2.size()) {
		s2.insert(*s1.rbegin());
		sum1-=*s1.rbegin();
		sum2+=*s1.rbegin();
		s1.erase(s1.find(*s1.rbegin()));
	}
}
void insert(int x) {
	if (s2.empty()) {
		s2.insert(x);
		sum2+=x;
	} else {
		if (x>=*s2.begin()) {
			s2.insert(x);
			sum2+=x;
		} else {
			s1.insert(x);
			sum1+=x;
		}
	}
	balance();
}
int check() {
	int mid=*s2.begin();
	int ans=sum2-mid*s2.size()+mid*s1.size()-sum1;
//	cout<<mid<<" "<<sum1<<" "<<s1.size()<<" "<<sum2<<" "<<s2.size()<<" "<<ans<<"***\n";
//	cout<<mid<<"***"<<ans<<"\n";
	if (ans>k) {
		return 1;
	}
	return 0;
}
void erase(int x) {
	if (!s1.empty()&&s1.find(x)!=s1.end()) {
		s1.erase(s1.find(x));
		sum1-=x;
	} else {
		s2.erase(s2.find(x));
		sum2-=x;
	}
	balance();
}
void solve() {
	init();
	cin>>n>>k;
	for (int i=1; i<=n; i++) {
		cin>>a[i];
		a[i]-=i;
	//	cout<<a[i]<<" ";
	}
//	cout<<"\n";
	int l=1;
	int maxx=0;
	for (int r=1; r<=n; r++) {
		insert(a[r]);
		while (l<r&&check()) {
			erase(a[l]);
			l++;
		}
//		cout<<l<<" "<<r<<"***\n";
		maxx=max(maxx,r-l+1);
	}
	cout<<maxx<<"\n";
}
signed main() {
	ios::sync_with_stdio(false);
	cin.tie(nullptr), cout.tie(nullptr);
	int T;
	// T = 1;
	cin >> T;
	while (T--) {
		solve();
	}
	return 0;
}