Str 真题解（置换）

目录

• 题面
• 置换
  • 这里没有群论
  • 置换
  • 置换的乘法（复合）
  • 置换乘法的单位元
  • 置换乘法的结合律
  • 置换快速幂
  • 置换求乘法逆
• 真题解
• 一种可能的代码实现
• 关于循环节做法

题面

对于字符串 $s$ 定义一个变换 $f(s)$ 表示， $\forall 1\le k\le \lfloor|s|/2\rfloor$ ，将 $s$ 中从后往前第 $k$ 个字符插入从前往后第 $k$ 个字符和第 $k+1$ 个字符之间后得到的字符串，例如 $\texttt{abcdef}$ 变换后得到 $\texttt{afbecd}$ .

现在给出用 $f(s)$ 变换过 $k$ 次以后的字符串（即执行 $k$ 次 $s:=f(s)$），求变换之前的字符串 .

（别骂我，这是原题面）

$3\le |s|\le 10^3, 1\le k\le 10^9$ .

置换

这里没有群论

这里没有群论 .

这里的置换是狭义的，正经置换看 OI-Wiki（内含 Burnside，慎入）

置换

一个置换 $p$ 定义为一个排列，置换相当于一个运算，将原来在位置 $i$ 的东西变到位置 $p_i$ .

置换的乘法（复合）

你对一个东西施加置换 $p$ 然后施加置换 $q$，就相当于施加 $p\circ q$ .

显然新的置换 $h=p\circ q$ 由下式直接表示：

$$h_i=q_{p_i}$$

置换乘法的单位元

恒等置换 $id$ 定义为 $id_i=i$ .

显然任何置换 $p$ 满足 $p\circ id = id \circ p$，于是 $id$ 就是 $\circ$ 的单位元 .

置换乘法的结合律

结合律：

$$p\circ q\circ r = p\circ (q\circ r)$$

为啥？

这里我们用函数表示下标，因为下标实在太多了 .

$$(p\circ q\circ r)(i) = p(q(r(i))) = p((q\circ r)(r) = (p\circ (q\circ r))(i)$$

Q.E.D. 是不是很显然 .

置换快速幂

有单位元，有结合律，显然可以 $\log$ 快速幂吧 .

置换求乘法逆

显然求逆就是把置换逆过来了（类似反函数？）（从施加的角度看，真的很显然）

原来是 $i\to p_i$，现在就是 $p_i\to i$ .

直接模拟算就完了 .

真题解

题目要求的 $f$ 可以看做一个置换 $p$ .

于是 $(p^{k})^{-1}$ 就是我们要对字符串 $s$ 施加的置换 .

直接算出来，时间复杂度 $O(|s|\log k)$ .

一种可能的代码实现

因为求逆可以先求也可以后求甚至可以直接拿眼看出来，所以可能的代码实现有很多 .

这里是先快速幂再求逆，应该是好理解的 .

// 增加了注释
#include <iostream>
#include <algorithm>
#include <cstring>
#include <cstdio>
#include <ctime>
#include <vector>
#include <queue>
#include <cmath>
#include <map>
#include <set>
#include <bitset>
#include <cassert>
using namespace std;
const int N = 1555;
int k;
string s;
struct perm // 置换
{
	perm(int x=1){n=x; for (int i=1; i<=x; i++) a[i] = i;} // 初始化为恒等置换
	int operator [](const unsigned& id)const{return a[id];}
	int& operator [](const unsigned& id){return a[id];} // 元素
	perm operator * (const perm& rhs)const // 乘法
	{
		assert(n == rhs.n);
		perm x(n);
		for (int i=1; i<=n; i++) x[i] = rhs[a[i]];
		return x;
	}
	perm& operator *= (const perm& rhs){return *this = *this * rhs;}
	perm inv() // 求逆
	{
		perm ans(n);
		for (int i=1; i<=n; i++) ans[a[i]] = i;
		return ans;
	}
	inline void prt() // debug
	{
		for (int i=1; i<=n; i++) printf("%d ", a[i]);
		puts("");
	}
	inline size_t size()const{return n;}
private:
	int n, a[N];
};
perm qpow(perm a, int n) // 快速幂
{
	perm ans(a.size());
	while (n)
	{
		if (n&1) ans *= a;
		a *= a; n >>= 1;
	} return ans;
}
perm create(int n) // 生成题目说的变换 f
{
	perm ans(n);
	int ptr1 = 1, ptr2 = n, cc = 0;
	while (ptr1 <= ptr2){ans[++cc]=ptr1; if (cc<n) ans[++cc]=ptr2; ++ptr1; --ptr2;}
	return ans;
}
int main()
{
	scanf("%d", &k);
	cin >> s; int l = s.length(); s = "$" + s;
	perm ans = qpow(create(l), k).inv();
	for (int i=1; i<=l; i++) putchar(s[ans[i]]); // 对 s 施加置换
	puts("");
	return 0;
} 

关于循环节做法

看起来这个东西有循环节？打了一发直接过了，出题人可真 sb

实际上我们可以证明这个东西有循环节且循环节是不大于 $|s|$ 的 .

从置换的角度考虑，如果 $i$ 能到 $p_i$ 就连一条 $i\to p_i$ 的有向边 .

$n$ 个点 $n$ 条边显然可以构成一个内向基环树森林，运算相当于在图上走一次，一直走肯定能走到环上 .

这说明任何置换 $p$ 的方幂都是有循环节的 .

然而这题里的 $p$ 更加特殊：

咕咕咕