比赛链接

这场不难，$G$ 和 $H$ 比较有意思。$G$ 题需要一定的二进制和数据结构的知识，$H$ 题是个 $2-sat$ 的题，算法名字吓人但是其实很简单，题目本身也很板，建议趁机学习一波。

---

A. My First Sorting Problem

题意 :

给你两个整数 $x$ 和 $y$ 。

输出两个整数： $x$ 和 $y$ 的最小值，以及 $x$ 和 $y$ 的最大值。

思路：

签到

code：

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
 
int T,a,b;
 
int main(){
	cin>>T;
	while(T--){
		cin>>a>>b;
		if(a>b)swap(a,b);
		cout<<a<<" "<<b<<endl;
	}
	return 0;
}

---

B. Different String

题意：

给你一个由小写英文字母组成的字符串 $s$ 。

将 $s$ 中的字符重新排列，组成一个新的字符串 $r$ ，这个字符串不等于 $s$ ，或者报告说这是不可能的。

思路：

如果不可以变成另一个字符串，那么这个字符串一定是由同一个字符组成的。要不然我们就可以选择两个不同的字符交换位置，这样得到的字符串就是不一样的。

我们不妨先选择第一个字符，然后向后找与它不同的字符串，然后交换一下即可。查找不同字符可以使用 string 的成员函数 int string::find_first_not_of(str,pos)，它的作用是从第 $pos$ 位置开始从前到后寻找第一个不在 $str$ 中出现的字符，并返回它的下标位置，如果找不到则返回 string::npos。

和它作用类似的还有 find_first_of()，find_last_of()，find_last_not_of()。成员函数 find(str,pos) 的作用是找 str，是子串匹配，而不是找字符。

code：

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
 
int T;
string s;
 
int main(){
	cin>>T;
	while(T--){
		cin>>s;
		int idx=s.find_first_not_of(s[0],1);
		if(idx==string::npos)puts("NO");
		else {
			puts("YES");
			swap(s[0],s[idx]);
			cout<<s<<endl;
		}
	}
	return 0;
}

---

C. Clock and Strings

题意：

如下图所示，有一个时钟，上面按顺时针顺序标有 $1$ 到 $12$ 的数字。

在本例中， $(a,b,c,d)=(2,9,10,6)$ 和字符串相交。

爱丽丝和鲍勃有四个不同的整数 $a$ 、 $b$ 、 $c$ 、 $d$ ，且不大于 $12$ 。爱丽丝用红色字符串连接 $a$ 和 $b$ ，鲍勃用蓝色字符串连接 $c$ 和 $d$ 。这两条线相交吗？(字符串是直线段）。

思路：

因为题目说了 $a,b,c,d$ 互不重复，我们就不考虑相等的特殊情况了。因为 $a,b$ 没有先后顺序，所以不妨令 $a<b$，方便讨论，同理 $c<d$

手玩一下发现只有 $a<c<b<d$ 或者 $c<a<d<b$ 两种情况下会相交。判断一下即可。

code：

#include <iostream>
#include <cstdio>
using namespace std;
 
int T,a,b,c,d;
 
int main(){
	cin>>T;
	while(T--){
		cin>>a>>b>>c>>d;
		if(a>b)swap(a,b);
		if(c>d)swap(c,d);
		puts(((a<c && c<b && b<d) || (c<a && a<d && d<b))?"YES":"NO");
	}
	return 0;
}

---

D. Binary Cut

题意：

给你一个二进制字符串 ${}^{†}$ 。请找出最少需要切割成多少个片段，以便将得到的片段重新排列成一个有序的二进制字符串。

请注意

• 每个字符必须正好位于其中一个片段中；
• 片段必须是原始字符串的连续子串；
• 在重新排列时必须使用所有片段。

${}^{†}$ 二进制字符串是由字符 $\text{0}$ 和 $\text{1}$ 组成的字符串。排序后的二进制字符串是指所有字符 $\text{0}$ 都位于所有字符 $\text{1}$ 之前的二进制字符串。

思路：

因为 $0$ 在前，$1$ 在后，因此我们在切割的时候，除了一段可以是前面一段 $0$ 后面一段 $1$ 以外，其他的段必须切成全 $0$ 或全 $1$。

考虑前面一段 $0$ 后面一段 $1$ 这种怎么切会比较复杂，我们可以把它看成是一个全 $0$ 段和一个全 $1$ 段，只不过中间接起来了。这样我们只需要先把原片段切成全 $0$ 段和全 $1$ 段就行了，显然我们在 $0\to 1$ 和 $1\to 0$ 变化的中间切就行了，数一下。

然后我们再把一个全 $0$ 段和一个全 $1$ 段中间接起来，当作没切过，在答案上减一。不过我们不能保证原片段一定存在前面一段 $0$ 后面一段 $1$ 的情况，所以我们再看一下有没有 $0\to 1$ 的变化，没有就说明不能拼起来，也就不能给答案减一。

code：

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
 
int T;
string s;
 
int main(){
	cin>>T;
	while(T--){
		cin>>s;
		int n=s.length(),cnt=1;
		bool flag=false;//0->1
		for(int i=1;i<n;i++){
			if(s[i-1]=='0' && s[i]=='1')flag=true;
			if(s[i]!=s[i-1])cnt++;
		}
		cout<<cnt-flag<<endl;
	}
	return 0;
}

---

E. Find the Car

题意：

Timur 坐在一辆汽车上，从点 $0$ 沿数线行驶到点 $n$ 。在第 $0$ 分钟，汽车从第 $0$ 点开始行驶。

在 $0,a_1,a_2,\dots ,a_k$ 点的直线上有 $k+1$ 个标志，帖木儿知道汽车将分别在 $0,b_1,b_2,\dots ,b_k$ 分钟到达那里。序列 $a$ 和 $b$ 与 $a_k=n$ 严格递增。

在任意两个相邻的标志牌之间，汽车以恒速行驶。帖木儿有 $q$ 个查询：每个查询都是一个整数 $d$ ，帖木儿希望您输出汽车到达点 $d$ 所需的时间，向下取整为最接近的整数。

思路：

有的翻译是错的，向下取整翻译成了四舍五入了，如果有错的可以看一下。

思路还是很明显的，我们在 $a$ 数组中二分找到第一个小于等于 $d$ 的位置 $i$，我们再从 $a_i$ 出发匀速走到 $d$，速度可以通过 $v=\frac{a_{i+1}-a_i}{b_{i+1}-b_i}$ 计算得到。注意特判 $d=a_k$ 的情况，因为没有后继节点，是算不出速度的。

code：

#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;
const int maxn=1e5+5;
typedef long long ll;
 
int T,n,k,q,d;
int a[maxn],b[maxn];
 
int main(){
	cin>>T;
	while(T--){
		cin>>n>>k>>q;
		for(int i=1;i<=k;i++)cin>>a[i];
		for(int i=1;i<=k;i++)cin>>b[i];
		
		while(q--){
			cin>>d;
			if(d==n){
				cout<<b[k]<<" ";
				continue;
			}
			int i=upper_bound(a,a+k+1,d)-a-1;
			cout<<b[i]+1ll*(b[i+1]-b[i])*(d-a[i])/(a[i+1]-a[i])<<" ";
		}
		cout<<endl;
	}
	return 0;
}

---

F. Circle Perimeter

题意：

给定整数 $r$ ，求与 $(0,0)$ 的欧氏距离大于或等于 $r$ ，但严格小于 $r+1$ 的格点个数。大于或等于 $r$ ，但严格小于 $r+1$ 的网格点的个数。

网格点是具有整数坐标的点。从 $(0,0)$ 到点 $(x,y)$ 的欧氏距离为 $\sqrt{x^2+y^2}$。

思路：

我们可以先算出半径为 $r+1$ 的圆内点的个数，然后减去半径为 $r$ 的圆内点的个数，答案即为所求。

听同学说是个高斯圆问题，也就是圆内整点问题。这个问题有一些数学家的猜想之类的，不过也仅限于猜想。这个题给定 $\sum r=10^5$，数据范围其实并不大，所以不用数学家的奇淫寄巧，直接暴力也是可做滴。

我们可以先计算图中红色部分的圆内点的个数，然后乘以 $4$ 就可以得到所有点的个数了。计算红色部分的点的个数，我们可以枚举 $1\sim r$ 的每一列（因为圆的半径只有 $r$，所以最远到第 $r$ 列，外面就没点了），分别计算第 $i$ 列有多少个点，累加起来即可。

这样计算出来的是半径为 $r$ 的圆的点，我们再算一遍半径为 $r+1$ 的圆的点，后者减去前者即可。或者我们在算每一列的时候，直接算出在半径 $r+1$ 但不在 $r$ 内的点的个数。

code：

#include <iostream>
#include <cstdio>
#include <cmath>
using namespace std;
const int maxn=1e5+5;
typedef long long ll;
 
ll T,r;
 
ll ge(ll x){\\最小的>=x的数
	if(x<0)return 0;
	ll t=sqrt(x);
	while(t*t<x)t++;
	return t;
}
ll lt(ll x){\\最大的<x的数
	ll t=sqrt(x)+1;
	while(t*t>=x)t--;
	return t;
}
 
int main(){
	cin>>T;
	while(T--){
		cin>>r;
		ll ans=0;
		for(ll i=1;i<=r;i++){
			ans+=lt((r+1)*(r+1)-i*i)-ge(r*r-i*i)+1;
		} 
		cout<<ans*4<<endl;
	}
	return 0;
}

---

G. XOUR

题意：

给你一个由 $n$ 个非负整数组成的数组 $a$ 。

如果 $a_i\mathsf{XOR}{a}_j<4$ ，你可以交换位置 $i$ 和 $j$ 的元素，其中 $\mathsf{XOR}$ 是 按位异或。

求任意交换次数所能组成的词法最小数组。

如果在 $x$ 和 $y$ 相差的第一个位置上，有 $x_i<y_i$ ，那么数组 $x$ 在词法上比数组 $y$ 小。

思路：

如果 $a_i\oplus a_j<4$ 说明它们的二进制位在高位上是完全相同的，而最低的两位上则完全不受限制。所以我们不看低两位，如果高位相同的话，它们之间就可以相互交换位置，否则就不能。

我们把若干个高位相同的数提取出来，然后排个序，再放回空位上，对每一堆高位相同的数都做这样的操作，最后得到的就是词法最小数组。

写法应该很多，这里就给一个我自己的写法。

code：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <vector>
#include <map>
#include <queue>
#include <algorithm>
#define pii pair<int,int>
using namespace std;
const int maxn=2e5+5;
 
int T,n,a[maxn];
map<int,priority_queue<int,vector<int>,greater<int> > > val;
 
int main(){
	cin>>T;
	while(T--){
		cin>>n;
		for(int i=1;i<=n;i++){
			cin>>a[i];
			val[a[i]>>2].push(a[i]);
		}
		for(int i=1;i<=n;i++){
			auto &b=val[a[i]>>2];
			cout<<b.top()<<" ";
			b.pop();
		}
		cout<<endl;
	}
	return 0;
}

---

H. ±1

题意：

鲍勃有一个行数为 $3$ 列数为 $n$ 的网格，其中每一行都包含某个整数 $1\le i\le n$ 的 $a_i$ 或 $-a_i$ 。例如， $n=4$ 可能包含的网格如下所示：

$$\left[\begin{array}{cccc}{a}_1& -a_2& -a_3& -a_2\\ -a_4& a_4& -a_1& -a_3\\ a_1& a_2& -a_2& a_4\end{array}\right]$$

爱丽丝和鲍勃玩的游戏如下：

• 鲍勃向爱丽丝展示他的网格。
• 爱丽丝给鲍勃一个她自己选择的数组 $a_1,a_2,\dots ,a_n$ ，其中的元素都是 $-1$ 或 $1$。
• 鲍勃将这些值代入他的网格，组成一个由 $-1$ 和 $1$ 组成的网格。
• 鲍勃将每一列中的元素按单调不减的顺序排列。
• 如果中间一行的所有元素都是 $1$ ，则爱丽丝获胜；否则，鲍勃获胜。

例如，假设爱丽丝给鲍勃提供了上述网格的数组 $[1,-1,-1,1]$ 。那么会发生以下情况(为清晰起见，添加了颜色)：

$$\left[\begin{array}{cccc}{a}_1& -a_2& -a_3& -a_2\\ -a_4& a_4& -a_1& -a_3\\ a_1& a_2& -a_2& a_4\end{array}\right]\stackrel{[1,-1,-1,1]}{\to }\left[\begin{array}{cccc}1& 1& 1& 1\\ -1& 1& -1& 1\\ 1& -1& 1& 1\end{array}\right]\stackrel{\text{sort each column}}{\to }\left[\begin{array}{cccc}-1& -1& -1& 1\\ 1& 1& 1& 1\\ 1& 1& 1& 1\end{array}\right]$$
由于中间一行都是 $1$ ，因此爱丽丝获胜。

给定鲍勃的网格，判断爱丽丝是否可以选择数组 $a$ 来赢得游戏。

思路：

年轻人的第一个 $2-sat$，不会的就百度吧，这题很板。

有代码
详细讲解（有输出选取方案）
OI-wiki $主要是看这个\Rightarrow$2-sat 各种性质的证明

上面的文档里比较重要的性质有：

1. $2-sat$ 构造出的原图中，关系具有对称性和传递性。
2. 构造出的原图可能有强连通分量，连通分量中的点必须同时选取或者同时不选，对所有极大连通子图进行缩点，得到的新图就是一个有向无环图（DAG）。新图与原图等价，也具有对称性和传递性。
3. 假设新图中的某个点为 $S_i$，对应矛盾点为 $S_i^{\prime }$。对任意一对 $S_i,S_i^{\prime }$，$S_i$ 的后继节点与 $S_i^{\prime }$ 的前代节点相互对称。
4. 若问题无解，则在原图上必然存在一对 $A_i,A_i^{\prime }$，使得 $A_i,A_i^{\prime }$ 同属一个环（也就是在一个强连通分量中）。反之，如果每一对 $A_i,A_i^{\prime }$ 都不属于同一个环，则问题一定有解。我们可以通过拓扑序从底向上 $O(n)$ 选出一组可行解。

因为要求中间一行都是 $1$，所以 $-1$ 的个数不能大于 $1$，所以如果一列三个元素的其中一个是 $-1$ 的话，那么其他两个元素都必须是 $1$。

假设这三个元素分别是 $x,y,z$ 的话。如果 $x$ 取 $-1$，那么就可以推出 $y,z$ 取 $1$。用 $2-sat$ 来做的话，其实也就是连边 $-x\to y,-x\to z$，同理，还有连 $-y\to x,-y\to z,-z\to x,-z\to y$。

连好边之后就是很板的 $2-sat$。我们直接检查一下每个点和它的矛盾点不在同一个强连通块内即可（也就是上面的性质 $4$）。

code：

#include <iostream>
#include <cstdio>
#include <vector>
using namespace std;
const int maxn=505;
 
int T,n;
int a[maxn][3];
int id(int x){return (x<0)?-x+n:x;}
 
vector<int> g[maxn<<1];
 
int dfn[maxn<<1],low[maxn<<1],idx;
bool ink[maxn<<1];
int belong[maxn<<1],cnt;
//vector<vector<int> > scc;
vector<int> stk;
void tarjan(int u){
	dfn[u]=low[u]=++idx;
	stk.push_back(u);ink[u]=true;
	for(auto v:g[u]){
		if(!dfn[v]){
			tarjan(v);
			low[u]=min(low[v],low[u]);
		}
		else if(ink[v])low[u]=min(low[u],dfn[v]);
	}
	if(low[u]==dfn[u]){
		int nd;++cnt;
		do{
			nd=stk.back();
			stk.pop_back();
			ink[nd]=false;
			belong[nd]=cnt;
		}while(nd!=u);
	}
}
 
 
int main(){
	cin>>T;
	while(T--){
		cin>>n;
		for(int j=0;j<3;j++)
			for(int i=1;i<=n;i++)
				cin>>a[i][j];
		
		idx=cnt=0;
		for(int i=1;i<=2*n;i++){
			g[i].clear();
			dfn[i]=low[i]=belong[i]=0;
		}
		
		for(int i=1,x,y,z;i<=n;i++){
			x=a[i][0];y=a[i][1];z=a[i][2];
//			cout<<x<<" "<<y<<" "<<z<<endl;
			g[id(-x)].push_back(id(y));
			g[id(-x)].push_back(id(z));
			g[id(-y)].push_back(id(x));
			g[id(-y)].push_back(id(z));
			g[id(-z)].push_back(id(x));
			g[id(-z)].push_back(id(y));
		}
		
		for(int u=1;u<=2*n;u++)
			if(!dfn[u])
				tarjan(u);
		
		bool flag=true;
		for(int u=1;u<=n;u++){
			if(belong[id(u)]==belong[id(-u)])
				flag=false;
		}
		puts((flag)?"YES":"NO");
	}
	return 0;
}