比赛记录:Codeforces Round 932 (Div. 2) A~E

传送门:CF

[前题提要]:第一次赛时div2过四题,上大分,并且感觉E题十分有教育意义,故写篇题解记录一下

---

A - Entertainment in MAC

凭借简单的意识,不难发现越长越不优,又因为n是偶数,所以必然是操作2次就停止,所以最后答案要么是$reverse(s)$,要么是$reverse(s+reverse(s))$,后者相当于$s+reverse(s)$,所以比较一下两者大小即可得出答案.直接观察样例同样可以得出上述结论

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define root 1,n,1
#define ls (rt<<1)
#define rs (rt<<1|1)
#define lson l,mid,rt<<1
#define rson mid+1,r,rt<<1|1
inline ll read() {
	ll x=0,w=1;char ch=getchar();
	for(;ch>'9'||ch<'0';ch=getchar()) if(ch=='-') w=-1;
	for(;ch>='0'&&ch<='9';ch=getchar()) x=x*10+ch-'0';
	return x*w;
}
inline void print(__int128 x){
	if(x<0) {putchar('-');x=-x;}
	if(x>9) print(x/10);
	putchar(x%10+'0');
}
#define maxn 1000000
const double eps=1e-8;
#define	int_INF 0x3f3f3f3f
#define ll_INF 0x3f3f3f3f3f3f3f3f
int main() {
	int T=read();
	while(T--) {
		int n=read();string s;cin>>s;
		string s2;s2=s;
		reverse(s2.begin(),s2.end());
		if(s>s2) {
			cout<<s2+s<<endl;
		}
		else {
			cout<<s<<endl;
		}
	}
	return 0;
}

B - Informatics in MAC

一道思维题,但是维护$Mex$还是比较麻烦的,好久没维护过了,赛时多花了一点时间.
对于分成$k$段,每段的$Mex$都一样,这种题有一个经典的$trick$,就是对于分成$k$段来说,我们能不能直接用$2$来代替$k$.对于本题来说,显然是能的.因为对于两段相同的$Mex$来说,我们将其合并,$Mex$显然是不会改变的.所以我们只要枚举我们两段的分界点,然后维护前缀的$Mex$和后缀的$Mex$即可.
对于维护$Mex$,博主使用的$multiset+map$来维护

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define root 1,n,1
#define ls (rt<<1)
#define rs (rt<<1|1)
#define lson l,mid,rt<<1
#define rson mid+1,r,rt<<1|1
inline ll read() {
	ll x=0,w=1;char ch=getchar();
	for(;ch>'9'||ch<'0';ch=getchar()) if(ch=='-') w=-1;
	for(;ch>='0'&&ch<='9';ch=getchar()) x=x*10+ch-'0';
	return x*w;
}
inline void print(__int128 x){
	if(x<0) {putchar('-');x=-x;}
	if(x>9) print(x/10);
	putchar(x%10+'0');
}
#define maxn 1000000
const double eps=1e-8;
#define	int_INF 0x3f3f3f3f
#define ll_INF 0x3f3f3f3f3f3f3f3f
int a[maxn];
int main() {
	int T=read();
	while(T--) {
		int n=read();
		set<int>st1,st2;
		for(int i=0;i<=n;i++) {
			st1.insert(i);st2.insert(i);
		}
		map<int,int>mp1,mp2;
		for(int i=1;i<=n;i++) {
			a[i]=read();
			mp1[a[i]]++;st1.erase(a[i]);
		}
		int flag=0;
		for(int i=1;i<=n-1;i++) {
			mp1[a[i]]--;
			if(mp1[a[i]]==0) st1.insert(a[i]);
			st2.erase(a[i]);
			if(*st1.begin()==*st2.begin()) {
				flag=1;
				cout<<2<<endl;
				cout<<1<<" "<<i<<endl;cout<<i+1<<" "<<n<<endl;
				break;
			}
		}
		if(flag==0) {
			cout<<-1<<endl;
		}
	}
	return 0;
}

C - Messenger in MAC

感觉又是一道典题.
对于这类题目,首先将绝对值去掉(样例1解释特意不这么做,用心险恶),就会发现就是选一些数,贡献是 ∑ a i + m a x { b i } − m i n { b i } \sum a_i+max\{b_i\}-min\{b_i\} ∑ai​+max{bi​}−min{bi​}.此时应该想到对$b$进行排序,因为我们需要$b$的单调性.

然后发现$n$才2000,所以可以$n^2$.考虑将$a,b$的贡献分开,那么不难想到枚举$b$的上下限来固定$b$的贡献,诶,此时我们的问题就变成了,在所有满足$b_i\in [l,r]$的$a_i$中挑选最多的$a_i$并且使贡献满足我们的$limit$.

想一下怎么维护上述过程.考虑新加入的$a_i$,如果加入后不满足限制,那么我们必然去掉当前所有$a_i$中最大的那一个,然后将其去掉,此时我们必然是重新满足的.因为我们是因为加入的$a_i$导致不满足,所以一定满足(大不了我不要$a_i$了,直接去掉它).此部分直接用$set$来维护即可.
此时细心的同学就会发现一个问题了,在维护过程中假设此时我们的$b_r-b_l$的贡献就已经大于限制怎么办,也就是说此时我们去掉一个可能仍然不满足限制,其实此时的情况是贡献是必然是不及$b_{r-1}-b_l$的贡献的,因为我们当新加入了$r$,又去掉了一个,即使此时的情况不满足,但是由于我们并没有增加贡献,所以此时的贡献可以直接忽略.
(其实正确的做法应该是直接break,或者使用while循环,但是赛时没有想到上述情况,并且AC,写题解时发现这个问题所以想了想为什么)

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define root 1,n,1
#define ls (rt<<1)
#define rs (rt<<1|1)
#define lson l,mid,rt<<1
#define rson mid+1,r,rt<<1|1
inline ll read() {
	ll x=0,w=1;char ch=getchar();
	for(;ch>'9'||ch<'0';ch=getchar()) if(ch=='-') w=-1;
	for(;ch>='0'&&ch<='9';ch=getchar()) x=x*10+ch-'0';
	return x*w;
}
inline void print(__int128 x){
	if(x<0) {putchar('-');x=-x;}
	if(x>9) print(x/10);
	putchar(x%10+'0');
}
#define maxn 1000000
#define int long long
const double eps=1e-8;
#define	int_INF 0x3f3f3f3f
#define ll_INF 0x3f3f3f3f3f3f3f3f
struct Node{
	int a,b;
	bool operator < (const Node &rhs) const {
		return b<rhs.b;
	}
}node[maxn];int n,L;
signed main() {
	int T=read();
	while(T--) {
		n=read();L=read();
		for(int i=1;i<=n;i++) {
			node[i].a=read();node[i].b=read();
		}
		sort(node+1,node+n+1);
		int ans=-int_INF;
		for(int i=1;i<=n;i++) {
			multiset<int>st;
			int sum=0;
			for(int j=i;j<=n;j++) {
				st.insert(node[j].a);
				sum+=node[j].a;
				if(sum+node[j].b-node[i].b>L) {
					sum-=*st.rbegin();
					st.erase(st.find(*st.rbegin()));
				}
				ans=max(ans,(int)st.size());
			}
		}
		cout<<ans<<endl;
	}
	return 0;
}

D - Exam in MAC

正难则反.
发现直接考虑满足两个否命题的点对很难考虑,那么直接考虑满足其中一个否命题的逆命题的点对个数.(这种方法在CF中十分常见).所有的点对个数一共有$(1+c+1)\ast (c+1)/2$个
考虑对于一个$a_i$,满足$x+y=a_i$的点对的个数,手玩一下就会发现是$s[i]/2+1$;同理,满足$y-x=a[i]$的个数是$c-s[i]$.难道这样就结束了?发现样例竟然过不去,出现了什么问题呢.
其实会发现上述计算过程是会有重复的,对于两个$a_i,a_j$来说,可能出现下面情况:$$x+y=a[i],y-x=a[j],a[i]>a[j]$$解一下$x,y$就会发现需要$a[i]+a[j],a[i]-a[j]$需要同奇偶.所以此时重复的个数显然就是在同奇偶的$<i,j>$中挑两个,这是简单的组合数问题.

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define root 1,n,1
#define ls (rt<<1)
#define rs (rt<<1|1)
#define lson l,mid,rt<<1
#define rson mid+1,r,rt<<1|1
inline ll read() {
	ll x=0,w=1;char ch=getchar();
	for(;ch>'9'||ch<'0';ch=getchar()) if(ch=='-') w=-1;
	for(;ch>='0'&&ch<='9';ch=getchar()) x=x*10+ch-'0';
	return x*w;
}
inline void print(__int128 x){
	if(x<0) {putchar('-');x=-x;}
	if(x>9) print(x/10);
	putchar(x%10+'0');
}
#define maxn 1000000
#define int long long
const double eps=1e-8;
#define	int_INF 0x3f3f3f3f
#define ll_INF 0x3f3f3f3f3f3f3f3f
int s[maxn];
signed main() {
	int T=read();
	while(T--) {
		int n=read();int c=read();
		for(int i=1;i<=n;i++) {
			s[i]=read();
		}
		int sum=0;
		for(int i=1;i<=n;i++) {
			sum+=s[i]/2+1;
			sum+=c-s[i];
		}
		int cnt1=0,cnt2=0;
		for(int i=1;i<=n;i++) {
			if(s[i]&1) cnt1++;
			else cnt2++;
		}
		sum-=cnt1*(cnt1-1)/2+cnt2*(cnt2-1)/2;
		cout<<(1+c+1)*(c+1)/2-sum<<endl;
	}
	return 0;
}

E - Distance Learning Courses in MAC

一道十分有教育意义的题目.个人十分喜欢这题.直接讲解法.
先来想一下如果我们的询问只有一组,我们该怎么办?
对于一个可选数字区间$[l,r]$,不难发现其实存在两种情况:
1.假设他们的二进制最高位都是1,那么显然的,最终的贡献$ans$这一位是1.
2.假设他们的二进制最高位是0,1,这种情况下,$ans$有两种选择,我们可以加入这一位的贡献,或者可以不要这一位的贡献,而将后面所有低位都改为1.

那么对于询问的下标区间$[a,b]$,计算这个区间的贡献,显然我们是从高位向低位贪心.对于当前为$i$来说:
1.如果存在一个$[l,r]$满足情况1,没有一个满足情况2,我们直接加入这一位的贡献.对于该点来说,贡献完这一位,剩余的可选区间为$[l-2^i,r-2^i]$,也就是剩余位,所以我们不需要进行操作.
2.满足情况1,并且满足情况2,那么此时我们可以直接将剩余位直接全部改为1,然后break.
3.只有一个满足情况2,此时我们必然需要将这一位加入我们的贡献,因为我们是从高位往低位进行贪心.此时不同于情况1,因为我们此时选择了右节点的最高位,所以贡献完这一位后,可选区间变成了$[0,r-2^i]$
4.超过2个满足情况2,此时我们可以任选一个加入这一位的贡献,然后另外一个将剩余位改为1,然后break.

此时我们的问题就变成了,如何快速的查询每一位有多少个可选区间满足情况1以及情况2.考虑预处理,将每一位满足情况1和情况2的下标存下来,之后对于给定的区间进行二分查询即可.
为了方便起见,我们可以在上述时候直接将所有情况1修改为情况2.因为情况一已经被记录下来了

对于修改方面,直接在线修改的话我们每次都需要复原,维护起来就比较比较麻烦,我们会发现有一个很优秀的性质,就是我们将后序的区间放到最后再一起进行贡献,此时的答案依旧是正确的.这句话什么意思呢,就是对于可选区间下标$[l,r]$,我们可以先算$[l,r-1]$的贡献,然后加入区间$r$的贡献,此时的贡献和一起考虑他们的时候是一样的.因为对于同一位多个情况2来说,交换贡献的时刻并没有问题.所以我们直接将上述要修改的区间离线下来再维护就行.

---

下面是具体的代码部分:

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define root 1,n,1
#define ls (rt<<1)
#define rs (rt<<1|1)
#define lson l,mid,rt<<1
#define rson mid+1,r,rt<<1|1
inline ll read() {
	ll x=0,w=1;char ch=getchar();
	for(;ch>'9'||ch<'0';ch=getchar()) if(ch=='-') w=-1;
	for(;ch>='0'&&ch<='9';ch=getchar()) x=x*10+ch-'0';
	return x*w;
}
inline void print(__int128 x){
	if(x<0) {putchar('-');x=-x;}
	if(x>9) print(x/10);
	putchar(x%10+'0');
}
#define maxn 1000000
const double eps=1e-8;
#define	int_INF 0x3f3f3f3f
#define ll_INF 0x3f3f3f3f3f3f3f3f
struct Node{
	int x,y;
}node[maxn];
int highbit(int x) {
	if(x==0) return -1;
	else return 31-__builtin_clz(x);
}
int main() {
	int T=read();
	while(T--) {
		int n=read();
		vector<int>v1[31],v2[31];
		//v1表示必为1的位置的线段,v2表示可以为1的位置的线段
		for(int i=1;i<=n;i++) {
			node[i].x=read();node[i].y=read();
			int tempx=node[i].x;int tempy=node[i].y;
			while(tempx!=0&&highbit(tempx)==highbit(tempy)) {
				int t=highbit(tempx);
				v1[t].push_back(i);
				tempx-=(1<<t);tempy-=(1<<t);
			}
			if(tempy) {
				v2[highbit(tempy)].push_back(i);
			}
			node[i].x=tempx;node[i].y=tempy;
		}
		int Q=read();
		for(int i=1;i<=Q;i++) {
			int ans=0;
			int l=read();int r=read();
			for(int j=30;j>=0;j--) {
				auto pos=lower_bound(v1[j].begin(),v1[j].end(),l);
				if(pos!=v1[j].end()&&*pos<=r) {
					ans|=(1<<j);
				}
			}
			priority_queue<pair<int,int> >q;
			for(int j=30;j>=0;j--) {
				auto pos=lower_bound(v2[j].begin(),v2[j].end(),l);
				if(pos==v2[j].end()) continue;
				int num=0;
				if(*pos<=r) {
					num++;pos++;
					if(pos!=v2[j].end()&&*pos<=r) {
						num++;
					}
				}
				if(num==0) continue;
				else if(num==1) {
					if(ans&(1<<j)) {
						ans|=((1<<j)-1);
						break;
					}
					else {
						ans|=(1<<j);pos--; 
						q.push({highbit(node[*pos].y-(1<<j)),node[*pos].y-(1<<j)});
					}
				}
				else {
					ans|=(1<<j)|((1<<j)-1);
					break;
				}
			}
			while(!q.empty()) {
				auto f=q.top();q.pop();
				if(f.second==0) break;
				if(ans&(1<<f.first)) {
					ans|=((1<<f.first)-1);
					break;
				}
				else {
					ans|=(1<<f.first);
					q.push({highbit(f.second-(1<<f.first)),f.second-(1<<f.first)});
				}
			}
			cout<<ans<<" ";
		}
		cout<<endl;
	}
	return 0;
}