LGR-144-题解

目录

• A. 新概念报数
  • Description
  • Solution
  • Code
• B. 河外塔
  • Description
  • Solution - 1
  • Code - 1
  • Solution - 2
  • Solution - 3
  • Code - 3
• C. 有效打击
  • Description
  • Data range
  • Solution - 1
  • Code - 1
  • Solution - 2
  • Code - 1 & 2

A. 新概念报数

Description

现在 A 和 B 玩起了报数游戏，但是他们非常喜欢 $2$ 这个数字，于是制定了如下规则：

• 如果一个数 $0\le a\leq2^{63}$ 满足 $\operatorname{popcount}(a) \geq 3$，那么这个数字是非法的，对方需要回答 No,Commander。
• 否则，这个数是合法的，对方需要回答下一个合法的数。

坐在旁边的你当然不知道游戏的乐趣，你只想知道某次报数之后对方应该回答什么。

Solution

其中 $\text{popcount}(a)$ 是指 $a$ 的二进制下的 $1$ 的个数，可通过 $\text{lowbit}$ 的 $\log n$ 求解，也可以通过倍增的 $\log(\log n)$ 求解。

• 如果 $\text{popcount}=0$ 时，即 $a=0$，此时下一个满足条件的数为 $1$。

• 如果 $\text{popcount}=1$ 时，即 $a= 2^x$，此时无论在任何位置添加 $2^y$ 都可以。当 $y=0$ 时，答案最小，即 $a+1$。

• 如果 $\text{popcount}=2$ 时，

  • 当 $a$ 为奇数时，二进制下的最低位为 $1$。此时对 $a+1$，二进制的数将会进位，但是并不会使得其 $\text{popcount}$ 变大，所以答案即为 $a+1$。

  • 当 $a$ 为偶数时，二进制下的最低位为 $0$。此时对 $a+1$，$\text{popcount}$ 将会变为 $3$，不合法。

    考虑奇数时的情况，将 $a$ 的最低位的 $1$ 上面加上 $1$。满足条件。

  答案可以归结为 $a+\text{lowbit}(a)$。

Code

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

inline int read(){
	int x = 0; bool f = false; char c = getchar();
	for (; !isdigit(c); f |= (c == '-'),c = getchar());
	for (; isdigit(c); x = (x<<1) + (x<<3) + (c^48),c = getchar());
	return f ? -x : x;
}

inline int lowbit(int x) {
	return (x)&(-x); 
}

inline int popcount(int x) {
	x = (x & 0x5555555555555555) + ((x >> 1) & 0x5555555555555555);
	x = (x & 0x3333333333333333) + ((x >> 2) & 0x3333333333333333);
	x = (x & 0x0f0f0f0f0f0f0f0f) + ((x >> 4) & 0x0f0f0f0f0f0f0f0f);
	x = (x & 0x00ff00ff00ff00ff) + ((x >> 8) & 0x00ff00ff00ff00ff);
	x = (x & 0x0000ffff0000ffff) + ((x >> 16) & 0x0000ffff0000ffff);
	x = (x & 0x00000000ffffffff) + ((x >> 32) & 0x00000000ffffffff);
	return x; 
}

int n, k;

signed main() {
	int T = read();
	while (T -- ) {
		k = popcount(n = read());
		if (k >= 3)  {
			puts("No,Commander");
		}
		else {
			if (k == 2) cout << n + lowbit(n) << '\n';
			else cout << n + 1 << '\n';
		}
	} 
	return 0;
}

---

B. 河外塔

Description

但是，你可能没有听过河外塔问题。虽然但是，好像并没有河外塔问题。于是，伟大的 X_Xy 决定创造一个河外塔问题。

既然是河内塔问题的延申，就得有些一样的东西：有三个柱子
$A$，$B$ 和 $C$ ，以及 $n$ 个圆盘，其中编号为 $i$ 的圆盘的半径长为 $i$，这些圆盘最开始都在 $A$ 上，最终都要顺序（即从上往下从小到大）地移到 $C$ 上。

既然是河内塔问题的延伸，就得有些不同的东西：最开始在 $A$ 上面的圆盘并不是顺序的，由于这个限制，我们也不在意移动过程中的顺序，也就意味着你可以将一个大的圆盘放在小的圆盘上。

但是 X_Xy 很懒，他只想让你操作至多 $10^6$ 次。

Solution - 1

• 通过 $\text{stack}$ 模拟，时间复杂度 $\mathcal O(n^2)$。

假设现在需要将编号为 $x$ 的圆盘放在柱子 $C$ 上，而 $x$ 现在位于柱子 $A$ 上。

通过两个栈模拟柱子 $A,B$ 上面的圆盘。

将圆盘 $x$ 上面所有的圆盘以此放入柱子 $B$ 上，然后将圆盘 $x$ 放在柱子 $C$ 上。

Code - 1

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

inline int read(){
	int x = 0; bool f = false; char c = getchar();
	for (; !isdigit(c); f |= (c == '-'),c = getchar());
	for (; isdigit(c); x = (x<<1) + (x<<3) + (c^48),c = getchar());
	return f ? -x : x;
}

int n, k, a[10010];
bool A[10010], B[10010]; 
stack <int> As, Bs;
vector <string> ans;

signed main() {
	n = read();
	for (int i = 1; i <= n; i ++ ) A[a[i] = read()] = true;
	for (int i = n; i >= 1; i -- ) As.push(a[i]);
	for (int i = n; i >= 1; i -- ) {
		if (A[i] == true) {
			while (As.top() != i) {
				swap(A[As.top()], B[As.top()]);
				Bs.push(As.top()); As.pop();
				ans.push_back("A B\n");
			}
			A[As.top()] = false; As.pop();
			ans.push_back("A C\n");
		}
		else {
			while (Bs.top() != i) {
				swap(A[Bs.top()], B[Bs.top()]);
				As.push(Bs.top()); Bs.pop();
				ans.push_back("B A\n");
			}
			B[Bs.top()] = false; Bs.pop();
			ans.push_back("B C\n");
		}
	}
	cout << (k = ans.size()) << '\n';
	for (int i = 0; i < k; i ++ ) cout << ans[i];
	return 0;
}

Solution - 2

• 基数排序解决，时间复杂度为 $\mathcal O(2n\log n)$。

出现了是“鸽鸽子”（建议 $\text{bdfs}$ ）

Solution - 3

• 归并排序（分治）解决，时间复杂度为 $\mathcal O(\frac{3}{2}n\log n)$。

考虑这样一个过程：

1. 对于一段区间 $\left[l,r\right]$，我们可以先将 $[l,mid]$ 的数排完序放到柱子 $\text{tmp1}$ 上面，并且是逆序排列。

2. 再将区间 $\left(mid,r\right]$ 的数排完放到柱子 $\text{tmp2}$ 上面，并且是顺序排列。

3. 然后将柱子 $\text{tmp1}$ 上面的数放到柱子 $\text{tmp2}$ 上面。

定义几个操作为：

• $S\,\text{(l,\ r,\ from,\ to,\ tmep,\ type)}$ 表示为将区间在 $\left[l,r\right]$ 的数从柱子 $\text{from}$（ 借助柱子 $\text{temp}$）移动到柱子 $\text{to}$ 上面.

  其中 $\text{type}=\left\{0,1\right\}$, 表示到柱子 $\text{to}$ 时是逆序排列或是正序排列。

• $F\,\text{(k,from,to)}$ 表示将 $k$ 个数，从柱子 $\text{from}$ 移动到柱子 $\text{to}$ 上面，顺序将会相反。

• $D\,\text{(k,\ from,\ to1,\ to2,\ }\Delta)$ 表示为将柱子 $\text{from}$ 上的 $k$ 个数字，分别放到柱子 $\text{to1}$ 和 $\text{to2}$ 上面。

  其中将 $\le\Delta$ 的数放在 $\text{to1}$ 上面，大于 $\Delta$ 的数放在 $\text{to2}$ 上面。

可以发现其答案就是 $S\,\text{(1,\ n,\ A,\ C,\ B,\ 1)}$。

每次操作这样的过程 $S\,\text{(l,\ r,\ from,\ to,\ tmep,\ 1)}$ 可以转化为：

$$D\,\text{(r-l+1, from, to, temp, mid)}\to S\,\text{(l, mid, to, from, tmp, 0)}\to\\ S\,\text{(mid+1, r, tmp, to, from, 1)}\to F\,\text{(mid-l+1, from,to)}$$

当 $\text{type}=0$ 时相似。

其中当 $l=r$ 时，$S$ 操作等价于 $F$ 操作。

Code - 3

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

inline int read(){
	int x = 0; bool f = false; char c = getchar();
	for (; !isdigit(c); f |= (c == '-'),c = getchar());
	for (; isdigit(c); x = (x<<1) + (x<<3) + (c^48),c = getchar());
	return f ? -x : x;
}

const int A = 1, B = 2, C = 3;
#define mid ((l + r) >> 1) 

int k[4][100100];
vector < pair<int,int> > ans;

void move(int frm, int to) {
	ans.push_back(make_pair(frm, to));
	k[to][ ++ k[to][0]] = k[frm][k[frm][0] -- ];
}

void F(int num, int frm, int to) {  
	while (num -- ) move(frm, to);
}

void D(int num, int frm, int to1, int to2, int dlt) {
	while (num -- ) {
		if (k[frm][k[frm][0]] <= dlt) move(frm, to1);
		else move(frm, to2);
	}
}

void S(int l, int r, int frm, int to, int tmp, int typ) {
	if (l == r) return F(1, frm, to); 
	if (typ == 1) {
		D(r - l + 1, frm, to, tmp, mid);
		S(l, mid, to, frm, tmp, typ ^ 1);
		S(mid + 1, r, tmp, to, frm, typ);
		F(mid - l + 1, frm, to);
	}
	else {
		D(r - l + 1, frm, tmp, to, mid);
		S(mid + 1, r, to, frm, tmp, typ ^ 1);
		S(l, mid, tmp, to, frm, typ);
		F(r - mid, frm, to); 
	}
}

signed main() {
	k[A][0] = read();
	for (int i = k[A][0]; i >= 1; i -- ) {
		k[A][i] = read();
	}
	S(1, k[A][0], A, C, B, 1); 
	cout << ans.size() << '\n';
	for (pair<int,int> it : ans)
		printf("%c %c\n",it.first + 64, it.second + 64);
	return 0;
}

---

C. 有效打击

Description

定义：若序列 $\Alpha$ 为

$$\underbrace{AA...A}_{a_1\textsf 个}\ \underbrace{BB...B}_{a_2\textsf 个}\ \underbrace{CC...C}_{a_3\textsf 个}\ \dots$$

序列 $\Beta$ 为

$$\underbrace{AA...A}_{b_1\textsf 个}\ \underbrace{BB...B}_{b_2\textsf 个}\ \underbrace{CC...C}_{b_3\textsf 个}\ \dots$$

其中 $A,B,C,a_1,a_2,a_3,...,b_1,b_2,b_3,...\in N_+$。

若有 $\dfrac{a_1}{b_1}=\dfrac{a_2}{b_2}=\dfrac{a_3}{b_3}=...=k\ , k>0$，则称 $\Alpha$ 与 $\Beta$ 互为相似序列。

特别的，长度为 $0$ 的序列不与任何序列成相似序列。

不难证明此定义下序列间的相似具有传递性。

求给定的序列 $A$ 中有多少个子串与给定序列 $B$ 互为相似序列。

Data range

数据点	n	m	特殊性质
1~2	$\leq 20000$	$\leq 20000$	无
3~4	$\leq 5 \times 10^6$	$\leq 5 \times 10^6$	A
5~6	$\leq 5 \times 10^6$	$\leq 5 \times 10^6$	B
7~10	$\leq 5 \times 10^6$	$\leq 5 \times 10^6$	C

对于 $100\%$ 的数据，保证有 $\forall\ i\in[1,n]$，$1\leq A_i \leq 7$；$\forall\ i\in[1,m]$，$1\leq B_i\leq 7$。

对于 $100\%$ 的数据，保证 $1\leq n,m\leq 5 \times 10^6$。

特殊性质 A：保证 $\forall\ i,j\in [1,m]，B_i=B_j$。

特殊性质 B：保证有且仅有一个 $k\in[1,m-1]$，使得 $\forall \ i,j\in[1,k]$，$B_i=B_j$；$\forall \ i,j\in[k+1,m]$，$B_i=B_j$。

特殊性质 C：保证第 $10$ 个点中 $n,m \leq 5\times 10^5$，且其他点中连续段仅有不超过 $100$ 种不同的长度。

Solution - 1

• 对于特殊性质 A。

保证了序列 $B$ 中只会出现一个数，可以将其缩为一个数，那么对于序列 $A$ 来讲，只需要找出只包含 $B_i$ 的子序列的个数即可。

这样的子序列是一个连续的 $B_i$，令其长度为 $\ell$，那么这段的贡献就是 $\dfrac{\ell(\ell + 1)}{2}$。

• 对于特殊性质 B。

与特殊性质 A 同理，只需要找到 A 中相邻两个数恰好为 $B_1,B_m$ 的位置，然后统计即可。

序列 $B$ 中的 $B_1$ 与 $B_m$ 同时也可以缩小，但是需要使得 $B_1$ 和 $B_m$ 的比例相同，即最简形式（除以 $\gcd$ 即可）。

Code - 1

// A ... 
for (int i = 1; i <= n + 1; i ++ ) {
	if (a[i] != a[i - 1]){
		if (a[i - 1] == b[1]) ans += ((cnt + 1) * cnt)/2;
		cnt = 1;
	}
	else cnt ++;
}
cout << ans << '\n';
// B ...
r = gcd(k = cur, m - cur);
cur = cnt = 0;	
for (int i = 1; i <= n + 1; i ++ ) {
	if (a[i] != a[i - 1]) {
		if (a[i - 1] == b[m] && lst == b[1])
			for (int l = 1;;l ++ ) 
				if (l * k <= cur * r && l * (m - k) <= cnt * r) ans ++;
				else break;
		lst = a[i - 1];
		if (a[i - 1] == b[1]) cur = cnt;
		cnt = 1;
	}
	else cnt ++;
}
cout << ans << '\n';

Solution - 2

• 对于其他的数据，时间复杂度 $\mathcal O(n\sqrt m)$。(另外需结合特殊性质)

考虑到对于序列 $B$ 来讲，将其化为最简的形式会更为方便的计算，并且对答案不会产生影响。（对于一个连续的数的个数除以其 $\gcd$ 即可）

for (int i = 1; i <= cnt; i ++ )
	if (r == -1) r = B[i].tot;
	else r = gcd(r, B[i].tot);

for (int i = 1; i <= cnt; i ++ ) B[i].tot /= r;

我们发现，对于这个最简形式，所有的连续的段的倍数所形成的序列^[1]，都是其满足条件的序列 $A$。

那么对于这形成的所有的序列 $B'$ ，只有长度小于等于序列 $A$ 的序列，才满足可尝试匹配的条件，这些大约是 $\sqrt{m}$ 个（ 吗？）。

然后对于每个序列 $B'$，对序列 $A$ 进行匹配算法。（可以用 $\text {KMP}$ 匹配算法，或是字符串哈希等等）。

Code - 1 & 2

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

const int N = 5e6 + 7;
const long long mod = 13537;

inline int read(){
	int x = 0; bool f = false; char c = getchar();
	for (; !isdigit(c); f |= (c == '-'),c = getchar());
	for (; isdigit(c); x = (x<<1) + (x<<3) + (c^48),c = getchar());
	return f ? -x : x;
}

inline int gcd(int a, int b) {
	while (b ^= a ^= b ^= a %= b);
	return a;
}

struct node {
	int t, s;
	long long tot;
	node(){}
	node(int a,int b, int c) {
		t = a; tot = b; s = c;
	} 
} w[N], e[N];
int n, m, top;
int cur, r = -1, k, cnt, lst, tmp;
long long hsh[N], p[N], sump[N], tit, hshu, ans, mx;
vector <int> g;

inline long long gethsh(int l, int r) {
	if (l > r) return 0;
	return hsh[r] - hsh[l - 1] * p[r - l + 1];
}

signed main() {
	n = read(); m = read();
	p[0] = 1ll; hsh[0] = 0; sump[0] = 1ll;
		
	for (int i = 1; i <= n; i ++ ) {
		int x = read();
		hsh[i] = hsh[i - 1] * mod + x;
		sump[i] = sump[i - 1] + (p[i] = p[i - 1] * mod);
		if (x != lst) e[++ top] = node(x, 1ll, i);
		else e[top].tot ++;
		lst = x;
	}
	lst = 0;
	for (int i = 1; i <= m; i ++ ) {
		int x = read();
		if (x != lst) w[++ cnt].t = x, w[cnt].tot = 1;
		else w[cnt].tot ++;
		if (x == w[1].t) cur ++;
		lst = x;
	}
	if (cnt == 1){
		for (int i = 1; i <= top + 1; i ++ )
			if (e[i - 1].t == w[1].t) ans += ((e[i - 1].tot + 1) * e[i - 1].tot) / 2;
	}
	else if (cnt == 2) {
		r = gcd(w[1].tot, w[2].tot);
		for (int i = 1; i <= top + 1; i ++ )
			if (e[i - 1].t == w[2].t && e[i - 2].t == w[1].t)
				for (int l = 1; ;l ++ )
					if (l * w[1].tot <= e[i - 2].tot * r && l * w[2].tot <= e[i - 1].tot * r) ans ++;
					else break;
	}
	else {
		e[top + 1].s = n + 1; 
		
		for (int i = 1; i <= top; i ++ ) {
			if (e[i].t == w[1].t) g.push_back(i);
			mx = max(mx, e[i].tot);
		}
		
		int sum = 0, ty = g.size();
		
		for (int i = 1; i <= cnt; i ++ )
			if (r == -1) r = w[i].tot;
			else r = gcd(r, w[i].tot);
			
		for (int i = 1; i <= cnt; i ++ ) sum += (w[i].tot /= r);
		
		for (int l = 1, tmp = sum; tmp <= n && l <= mx; l ++ ) {
			hshu = 0;
			for (int i = 1; i <= cnt; i ++ ) {
				hshu *= p[w[i].tot * l];
				hshu += w[i].t * sump[w[i].tot * l - 1];
			}
			
			for (int i = 0; i < ty && e[g[i]].s + tmp - 1 <= n ; i ++ ){
				if (e[g[i]].tot < w[1].tot * l) continue;
				tit = gethsh(e[g[i] + 1].s, e[g[i] + 1].s + tmp - w[1].tot * l - 1) + w[1].t * p[(tmp - w[1].tot * l)] * sump[w[1].tot * l - 1];
				if (tit == hshu) ans ++;
			}
			tmp += sum;
		}	
	}
	cout << ans << '\n';
	return 0;
}

(存在线性做法。。。

---

---

1. 如果最简形式为 $aab$，那么它的倍数就是 $aaaabb,aaaaaabbb,\dots$ ↩︎