【题解】Educational Codeforces Round 152（CF1849）

A.Morning Sandwich

题目描述：

吃货小 C 喜欢三明治，他有三种材料：面包、芝士、火腿。正确的三明治组合应为一层面包和一层芝士或火腿之一轮流放置，以面包为结尾，例如面包-芝士-面包-火腿-面包就是合法的三明治。

给定每次做三明治的材料：$b$ 面包，$c$ 芝士，$h$ 汉堡，求出小 C 最多做多少层三明治。

多测，$t$ 组数据。

$1 \le t \le 1000 ， 2 \le b \le 100 ， 1 \le c,h \le 100$。

题目分析：

可以将三明治的结构理解为：一层芝士/汉堡对应一层面包，在最后还要多来一个面包。
所以只需要 $b-1$ 与 $c + h$ 取 $\min$ 后加 $1$ 即可。

代码：

点击查看代码

#include<bits/stdc++.h>
using namespace std;
int main(){
	int T;scanf("%d",&T);
	while(T--){
		int a,b,c;scanf("%d%d%d",&a,&b,&c);
		if(a < 2)	printf("0\n");
		else{
			printf("%d\n",2 * min(a-1,b+c) + 1); 
		}
	}
	return 0;
}

B.Monsters

题目描述：

小 C 在玩一款全新开放世界冒险游戏。

本关卡有 $n$ 个怪物，小 C 一刀 $k$ 血，第 $i$ 怪物初始 $a_i$ 血。

怪物 0 血或负血会死掉。

小 C 每次打击目前剩余血量最多的怪物，如有多个打击编号最小的。

按照小 C 击杀怪物的顺序输出怪物编号。

多测，$t$ 组数据。

$1 \le t \le 10^4 ， 1 \le n \le 3 \times 10^5 ， 1 \le k,a_i \le 10^9$。

题目分析：

考虑这个过程是什么样的。
一样是先通过减 $k$ 将每一个 $a_i$ 变为 $\le k$ 的数，然后一击必杀。
所以就直接对 $k$ 取模然后按剩下的血量排序即可，注意的细节就是若 $a_i \mod k = 0$，则相当于减到 $k$ 而不是 $0$。

代码：

点击查看代码

#include<bits/stdc++.h>
#define PII pair<int,int>
using namespace std;
const int N = 1e6+5;
int a[N];
PII b[N];
bool cmp(PII a,PII b){
	if(a.first != b.first)	return a.first > b.first;
	return a.second < b.second;	
}
int main(){
//	freopen("in.txt","r",stdin);
//	freopen("out.txt","w",stdout);
	int T;scanf("%d",&T);
	while(T--){
		int n,k;scanf("%d%d",&n,&k);
		for(int i=1; i<=n; i++)	scanf("%d",&a[i]);
		for(int i=1; i<=n; i++){
			if(a[i] % k == 0)	a[i] = k;
			else	a[i] %= k;
		}
		for(int i=1; i<=n; i++)	b[i] = {a[i],i};
		sort(b+1,b+n+1,cmp);
		for(int i=1; i<=n; i++)	printf("%d ",b[i].second);
		printf("\n");
	}
	return 0;
}

C.Binary String Copying

题目描述：

小 C 获得了一个长度为 $n$ 的 01 串 $S$。

小 C 有 $m$ 次操作，每次操作形如 $[l,r]$，代表将 $S$ 复制，生成一个 $S$ 的副本，将副本 $[l,r]$ 区间内数字字符从小到大排序，第 $i$ 次操作生成的新串记为 $S_i$。操作间互不影响，互相独立。

求出有多少不同的 $S_i$。

多测，$t$ 组数据。

$1 \le t \le 10^4 ， 1 \le \sum n,\sum m \le 2 \times 10^5$。

题目分析：

这是一个 $01$ 串，所以对于 $[l,r]$ 从小到大排序之后其前缀 $0$ 和后缀 $1$ 的位置都不会改变，设 $l_1$ 代表从前到后第一个 $1$ 的位置 $r_1$ 代表从后到前第一个 $0$ 的位置，排序影响的只有 $[l_1,r_1]$。
也就是说我们可以将区间 $[l,r]$ 用区间 $[l_1,r_1]$ 替代，会发现的是当 $[l_1,r_1]$ 相同则字符串相同，当 $[l_1,r_1]$ 不同则字符串不同。
所以对于 $[l_1,r_1]$ 的种类计数即可。

代码：

点击查看代码

#include<bits/stdc++.h>
using namespace std;
const int N = 2e5+5;
int nxt[N],pre[N];
map<int,int> mp[N];
char s[N];
int main(){
//	freopen("in.txt","r",stdin);
//	freopen("out.txt","w",stdout);
	int T;scanf("%d",&T);
	while(T--){
		int n,m;scanf("%d%d",&n,&m);
		scanf("%s",s+1);
		nxt[n+1] = n+1; 
		for(int i=n; i>=1; i--){
			if(s[i] == '1')	nxt[i] = i;
			else	nxt[i] = nxt[i+1];
		}
		pre[0] = 0;
		for(int i=1; i<=n; i++){
			if(s[i] == '0')	pre[i] = i;
			else	pre[i] = pre[i-1];
		}
		int ans = 0;
		while(m--){
			int l,r;scanf("%d%d",&l,&r);
			l = nxt[l],r = pre[r];
			if(l >= r)	ans += !mp[0][0],mp[0][0] = true;
			else	ans += !mp[l][r],mp[l][r] = true;
		}
		printf("%d\n",ans);
		for(int i=0; i<=n; i++)	mp[i].clear();
	}
	return 0;
}

D.Array Painting

题目描述：

有一个长度为 $n$ 的数组 $a$，满足 $\forall a_i\in\{0,1,2\}$，一开始所有元素均为蓝色。

可以有如下操作：

• 用一枚硬币，把一个蓝色元素涂成红色；

• 选择一个不等于 $0$ 的红色元素和一个与其相邻的蓝色元素，将所选的红色元素减少 $1$，并将所选的蓝色元素涂成红色。

要将所有元素涂红，最少需要多少硬币？

题目分析：

考虑一次操作最优就是让极长的 $[l,r] (\forall i \in [l,r] , a[i] \ge 1)$ 全部被染红。
若区间最大值为 $1$ 则可以选择 $l-1$ 或 $r+1$ 额外染红。
若区间最大值为 $2$ 则可以选择 $l-1$ 和 $r+1$ 额外染红。
所以就可以考虑将所有的极长段拿出来，先考虑最大值为 $2$ 的区间再考虑最大值为 $1$ 的区间染色即可。
如果我们是从左到右依次考虑，那么对于最大值为 $1$ 的区间优先将 $l-1$ 染色最优，因为可以给后面更大的发挥空间。

代码：

点击查看代码

#include<bits/stdc++.h>
using namespace std;
const int N = 5e5+5;
struct node{
	int l,r,opt;
}b[N];
int a[N];
bool flag[N];
bool cmp(node a,node b){
	if(a.opt != b.opt)	return a.opt > b.opt;
	return a.l < b.l;
}
int main(){
//	freopen("in.txt","r",stdin);
//	freopen("out.txt","w",stdout);
	int n;scanf("%d",&n);
	for(int i=1; i<=n; i++)	scanf("%d",&a[i]);
	int tot = 0;
	for(int i=1; i<=n;){
		if(a[i] != 0){
			int pos = i;
			int mx = 0;
			for(;pos <= n && a[pos] != 0; ++pos);
			--pos;
			for(int j=i; j<=pos; j++)	mx = max(mx,a[j]);
			b[++tot] = {i,pos,mx};
			i = pos + 1;
		}
		else	i++;
	}
	sort(b+1,b+tot+1,cmp);
	int ans = 0;
	for(int p=1; p<=tot; p++){
		++ans;
		int l = b[p].l,r = b[p].r;
		for(int i=l;i <= r; i++)	flag[i] = true;
		if(l != 1 && !flag[l-1] && b[p].opt)	b[p].opt--,flag[l-1] = true;
		if(r != n && !flag[r+1] && b[p].opt)	b[p].opt--,flag[r+1] = true;
	}
	for(int i=1; i<=n; i++){
		if(!flag[i])	++ans;
	}
	printf("%d\n",ans);
	return 0;
}

E.Max to the Right of Min

题目描述：

现有一长度为 $n(n\leq 10^6)$ 的排列，求有多少子区间 $[l,r]$ 满足区间最大值出现在区间最小值的右侧。

题目分析：

做法一：
一个显然的想法就是枚举点东西，第一感觉就是枚举最大值和最小值，然后看贡献是个怎么样的式子，这个式子肯定可以快速对一个区间统计。
设 $lmx_i,rmx_i$ 分别表示左边/右边第一个比 $a_i$ 大的数，$lmn_i,rmn_i$ 表示左边/右边第一个比 $a_i$ 小的数。
令 $a_i$ 为最大值，$a_j$ 为最小值，其满足条件的区间的左右端点就是：$l \in [\max(lmx_i+1,lmn_j+1),j],r \in [i,\min(rmx_i-1,rmn_j-1)]$。
造成的贡献显然就是：$(j - \max(lmx_i+1,lmn_j+1) + 1) * (\min(rmx_i-1,rmn_j-1) - i + 1)$
这个东西可以对于 $\max,\min$ 的取值分类讨论，这样就可以转化为三维偏序就可以直接做了。
需要注意如果区间长度 $< 0$ 则不应统计，而不是作为负数统计。

做法二：
我们不直接枚举最大值和最小值，而是转化为枚举最大值和该区间的左端点/右端点。
设最大值位置为 $i$，则可能的左端点 $l \in [lmx_i+1,i]$，可能的右端点 $r \in [i,rmx_i-1]$。
那么我们到底是枚举左端点还是右端点呢，一个结论就是选择可能的区间长度最小的区间枚举即可。
这样的话考虑一下复杂度是什么，也就是一个点会被枚举到多少次。
若对应的区间为 $[lmx_i+1,rmx_i-1]$ 且我们选择了 $[i,rmx_i-1]$，则对于 $p \in [i,rmx_i-1]$ 在下一次被枚举到时其区间长度一定不超过 $[i,rmx_i-1]$，因为必然存在 $a_p < a_i$ 且 $a_p < a_{rmx_i-1}$，也就是区间长度会减半，所以一个点最多被枚举 $O(\log n)$ 次，时间复杂度 $O(n \log n)$。
需要特判枚举的端点为 $i$ 的情况。

做法三：
我们不搞那么多花里胡哨的，因为要我们统计多少个区间 $[l,r]$ 满足条件就直接考虑枚举 $r$ 然后判断有多少个 $l$ 符合条件。
直接维护很难所以考虑是不是可以增量地维护，也就是当 $r$ 变为 $r+1$ 时有什么变化，分类讨论：

• 若 $a_{r+1}$ 为最大值，则 $l \in [lmx_{r+1}+1,r]$ 都是合法的
• 若 $a_{r+1}$ 为最小值，则 $l \in [lmn_{r+1}+1,r]$ 都是不合法的
• 若 $a_{r+1}$ 不为最大值和最小值，则不会对原来的合法性产生任何影响。

所以就直接使用线段树维护区间赋值 $01$ 就可以了。
这里会有的疑问就是 $[lmx_{r+1}+1,r]$ 与 $[lmn_{r+1}+1,r]$ 相交的部分怎么办呢。
其实它们不可能相交，考虑一定存在 $a_r < a_{r+1}$ 或 $a_r > a_{r+1}$，也就是必然存在 $lmx_{r+1} = r$ 或 $lmn_{r+1} = r$，也就是肯定有一个区间为空，就不可能相交。

代码：

（做法三的代码）

点击查看代码

#include<bits/stdc++.h>
#define int long long
using namespace std;
const int N = 1e6+5;
int sum[4 * N],tag[4 * N],a[N],lmn[N],lmx[N];
void update(int now,int now_l,int now_r,int val){
	sum[now] = val * (now_r - now_l + 1);
	tag[now] = val;
}
void pushup(int now){
	sum[now] = sum[now<<1] + sum[now<<1|1];
}
void pushdown(int now,int now_l,int now_r){
	if(tag[now] == -1)	return;
	int mid = (now_l + now_r)>>1;
	update(now<<1,now_l,mid,tag[now]);
	update(now<<1|1,mid+1,now_r,tag[now]);
	tag[now] = -1;
}
void modify(int now,int now_l,int now_r,int l,int r,int val){
	if(l > r)	return;
	if(l <= now_l && now_r <= r){
		update(now,now_l,now_r,val);
		return;
	}
	pushdown(now,now_l,now_r);
	int mid = (now_l + now_r)>>1;
	if(l <= mid)	modify(now<<1,now_l,mid,l,r,val);
	if(r > mid)		modify(now<<1|1,mid+1,now_r,l,r,val);
	pushup(now);
}
void build(int now,int now_l,int now_r){
	tag[now] = -1;
	if(now_l == now_r)	return;
	int mid = (now_l + now_r)>>1;
	build(now<<1,now_l,mid);build(now<<1|1,mid+1,now_r);
}
signed main(){
//	freopen("in.txt","r",stdin);
//	freopen("out.txt","w",stdout);
	int n;scanf("%lld",&n);
	for(int i=1; i<=n; i++)	scanf("%lld",&a[i]);
	stack<pair<int,int> > st;
	for(int i=1; i<=n; i++){
		lmx[i] = 0;
		while(!st.empty() && st.top().first < a[i])	st.pop();
		if(!st.empty())	lmx[i] = st.top().second;
		st.push({a[i],i});
	}
	while(!st.empty())	st.pop();
	for(int i=1; i<=n; i++){
		lmn[i] = 0;
		while(!st.empty() && st.top().first > a[i])	st.pop();
		if(!st.empty())	lmn[i] = st.top().second;
		st.push({a[i],i});
	}
	int ans = 0;
	build(1,1,n);
	for(int i=1; i<=n; i++){
		modify(1,1,n,lmx[i]+1,i-1,1);
		modify(1,1,n,lmn[i]+1,i-1,0);
		ans += sum[1];
	}
	printf("%lld\n",ans);
	return 0;
}

F.XOR Partition

题目描述：

小 C 认为，一个数集 $S$ 的价值是这个数集中所有不同的数两两异或的最小值。数集大小不足 $2$ 则价值记为 $2^{30}$。

小 C 又认为，一个数集 $S$ 的一种分割方案的分割价值是这个数集分割成两个数集 $A$ 和 $B$，$A$ 和 $B$ 的价值的最小值。

求出使得分割价值取到最大的分割方案，如果多种输出任意一种。

$2 \le n \le 200000 ， 0 \le a_i < 2^{30}$。

题目分析：

一个想法就是每次找到 $a_i \oplus a_j$ 最小的数对，将这两个数分到不同的集合中，这样最后分出来就是最优解。
所以其实可以将最小异或的数对看成一条边，这样只要图为二分图就可以直接二分图染色。
那么只要图刚刚联通的时候，也就是为一棵树的时候就可以。

那么这个问题就是可以转化为一个类似瓶颈生成树的问题，也就是任意一条非树边权值均大于树边权值，其中 $(u,v)$ 的权值定义为 $a_u \oplus a_v$，而所以直接求最小生成树就一定对应这样的一棵瓶颈生成树。

那么对于最小异或生成树该怎么求呢。
异或尽可能小相当于在 trie 树上其 lca 的深度尽可能大，而最可能大的就是一条链最底部的也就是同时拥有两个儿子的点。
而我们每插入一个点只会最多新增一个同时拥有两个儿子的点，所以符合条件的点数为 $O(n)$。
就可以考虑枚举每一个符合条件的点，令子树大小最小的子树为左子树，然后枚举其左子树内的点，然后让它去和右子树匹配使得异或尽可能小。
这里可能就有问题就是如果点数达不到 $n-1$ 也就是最后不连通怎么办，这种情况的出现就是因为出现了异或为 $0$ 的情况，不会对答案产生任何影响。
分析一下复杂度，因为下一次枚举到某个点时，其对应子树的大小必然翻倍，而对于每一次枚举匹配的复杂度为 $O(\log V)$，所以总时间复杂度为 $O(n \log n \log V)$

代码：

点击查看代码

#include<bits/stdc++.h>
using namespace std;
const int N = 3e6+5;
const int INF = 1e9+5;
struct edge{
	int nxt,to;
	edge(){}
	edge(int _nxt,int _to){
		nxt = _nxt,to = _to;
	}
}e[2 * N];
struct node{
	int id,val;
}a[N];
int cnt,sz=1,id,head[N],col[N],ch[N][2],l[N],r[N];
bool vis[N];
bool cmp(node a,node b){
	return a.val < b.val;
}
void add_edge(int from,int to){
	e[++cnt] = edge(head[from],to);
	head[from] = cnt;
}
void insert(int now,int pos,int dep){
	if(dep == -1)	return;
	int s = (a[pos].val >> dep) & 1;
	if(ch[now][s])	r[ch[now][s]] = pos;
	else{
		ch[now][s] = ++sz;
		l[sz] = r[sz] = pos;
	}
	insert(ch[now][s],pos,dep-1);
}
int query(int now,int val,int dep){
	if(dep == -1){
		id = l[now];
		return 0;
	}
	int s = (val >> dep) & 1;
	if(ch[now][s])	return query(ch[now][s],val,dep-1);
	return query(ch[now][s^1],val,dep-1) + (1 << dep);
}
void solve(int now,int dep){
	if(dep == -1 || !now)	return;
	int x = ch[now][0],y = ch[now][1];
	if(x && y){
		if(r[x] - l[x] + 1 > r[y] - l[y] + 1)	swap(x,y); 
		int ans = INF,u = 0,v = 0;
		for(int i=l[x]; i<=r[x]; i++){
			int tmp = query(y,a[i].val,dep-1);
			if(ans > tmp)	ans = tmp,u = i,v = id;
		}
		add_edge(a[u].id,a[v].id);add_edge(a[v].id,a[u].id);
//		printf("%d %d\n",a[u].id,a[v].id);
	}
	solve(ch[now][0],dep-1);
	solve(ch[now][1],dep-1);
}
void dfs(int now,int val){
	col[now] = val;
	for(int i=head[now]; i; i=e[i].nxt){
		int to = e[i].to;
		if(col[to] != -1)	continue;
		dfs(to,val^1);
	}
}
int main(){
//	freopen("in.txt","r",stdin);
//	freopen("out.txt","w",stdout);
	int n;scanf("%d",&n);
	for(int i=1; i<=n; i++)	scanf("%d",&a[i].val),a[i].id = i;
	sort(a+1,a+n+1,cmp);
	for(int i=1; i<=n; i++)	insert(1,i,30);
	for(int i=1; i<=n; i++)	col[i] = -1;
	solve(1,30);dfs(1,0);
	for(int i=1; i<=n; i++)	printf("%d",col[i]);
	return 0;
}