本题来自 AcWing 143：给定一个字符串 s，对于每个前缀 s[1..i]（1 ≤ i ≤ n），求出它的最小循环元长度以及循环次数。
next[i] 的定义是：字符串 s[1..i] 的最长相等真前后缀的长度。也就是说，令 j = next[i]，则 s[1..j] = s[i-j+1..i]，且 j 是所有满足此条件的值中最大的。
令 m = i - next[i]，j = next[i]。
我们将前缀 s[1..i] 分成三段：
因为 next[i] = j，所以前缀 s[1..j] = 后缀 s[m+1..i]。对齐方式如下：
1
2
3
4
5
6
| 位置： 1 ... m | m+1 ... j | j+1 ... i |
| ----------------- ||------------| |----------|
前缀： s[1] ... s[m] s[m+1] ... s[j]
s[m+1] ... s[j] s[j+1] ... s[i]
|================|
中段 B 自重复
代入具体例子来理解：
1
2
3
4
5
6
7
8
9
10
11
例：s = "ababab"，i = 6，next[6] = 4，m = 2，j = 4
前缀 s[1..4] = "abab" = 后缀 s[3..6]
位置： 1 2 3 4 5 6
|-----|--------|
| 前缀： a b | a b | s[1..4] |
| ------------------ | ---- |
| 后缀： a b | a b | s[3..6] |
= = = =
a b = a b ← 重叠区 s[3..4] = s[1..2]
假设最小循环元长度为 len。我们证明 len = m = i - next[i]。
第一步：len 必须将中段 B 的长度 (j - m) 整除
中段 B = s[m+1..j] 既是前缀 s[1..j] 的前 j-m 个字符，也是后缀 s[m+1..i] 的后 j-m 个字符。如果整个串 s[1..i] 有周期 len，那么 s[1..j] 也有周期 len，B 作为 s[1..j] 的前缀，其长度必须是 len 的整数倍——否则 B 的首尾会出现不匹配，与 B 同时出现在前缀和后缀中矛盾。
第二步：反证法证明 len = m
假设 len ≠ m，分两种情况讨论：
情况1：假设 len < m
如果最小周期 len 比 m 还小，那么前段 A（长度 m）包含至少一个完整周期。由于 B 的起始位置 m+1 也是周期的对齐点，B 的结束位置 j = m + (j-m) 也是周期的对齐点。这意味着 s[1..j+len] 也是 s 的前缀且等于后缀 s[len+1..i+len]，从而存在长度 > j 的公共前后缀，与 next[i] = j（j 是最长相等真前后缀长度）矛盾。
图示说明：
1
2
3
4
5
6
7
8
9
10
假设 len < m，周期对齐如下：
位置： 1 ... len ... m ... j ... i
|--------|--------|------|------|
前缀： s[1] ... s[len] ... s[m] ... s[j]
|======================|
后缀： s[1] ... s[m] ... s[j]
|======================|
重叠区延伸到 j+len > j，
与 next[i]=j 矛盾
情况2：假设 len > m
如果最小周期 len 比 m 还大，那么重叠区 B 的长度 j - m 就小于 len，B 不可能被 len 整除（不够一个完整周期）。但另一方面，s[1..j] 被 len 整除地划分（因为 s[1..j] 是 s[1..i] 的前缀，继承周期性），所以 s[1..j] 可以被 len 整除地划分。由 s[1..j] = s[m+1..i]，后段 s[j+1..i] 也必须有同样的周期结构。但后段长度 = i - j = m < len，不够一个完整周期，矛盾。
图示说明：
1
2
3
4
5
6
7
8
9
假设 len > m，周期对齐如下：
位置： 1 ... m ... j ... i
|--------|------|------|
前缀： s[1] ... s[m] ... s[j]
s[m+1] ... s[j] s[j+1] ... s[i]
|----------------|
后段 s[j+1..i] 长度 = m < len，
不够一个完整周期，矛盾
综上，len = m = i - next[i]。
对于每个前缀 s[1..i]，令 m = i - next[i]：
#include
const int maxn = 1000002; // it is 1000000 + 1 + 1 char str[maxn]; int nex[maxn];
int main() { int cnt = 0; int n = 0;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
while (true) {
scanf("%d", &n);
if (!n) {
goto flag_end;
}
printf("Test case #%d\n", ++cnt);
scanf("%s", str + 1);
nex[0] = nex[1] = 0;
for (int i = 2, j = 0; i <= n; ++i) {
while (j > 0 && str[i] != str[j + 1]) {
j = nex[j];
}
if (str[i] == str[j + 1]) {
++j;
}
nex[i] = j;
const bool circular_element_exits = (i % (i - nex[i]) == 0) && nex[i] > 0;
if (circular_element_exits) {
printf("%d %d\n", i, i / (i - nex[i]));
}
}
printf("\n");
}
flag_end: return 0; }
]]>https://codeforces.com/problemset/problem/2246/A
这是一道A题，从A题的角度来看他似乎不够格，但做这道题时我发现它的思考角度是我很少考虑的，但却经常被使用的思路，那就是奇偶性，Codeforces Round 1108 (Div. 2)有很多题目都考察了奇偶性。
其实题目已经暗示了我们要考虑奇偶性，在题目中有一个even单词被加黑了，这是很明显的暗示。但这不是我们的目的，我们讨论真正的思路。我们不希望它的和有概率为1，那该怎么做，如果你在思考怎么避免成为1，那你很可能想错了，1是一个元素，他有很多种情况，你得考虑每一个元素的变化对整体的影响，那不妨以更高的角度思考这个问题，如果1是某个集合的元素，而这个集合被排除那也意味着1也会被排除，最简单的角度就是奇偶性，1是奇数，如果我可以保证它的和不为奇数，他就一定不能为1。那我可以考虑让他们的每一项都只能为偶数，又因为𝑆𝑖={−𝑖⋅𝑝𝑖,0,𝑖⋅𝑝𝑖}，我们可以让i为奇数时，让pi为偶数，当i为偶数时，pi为奇数。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
namespace {
const int N = 1e6 + 1;
const int INF = 0x3f3f3f3f;
} // namespace
void solve() {
int n;
cin >> n;
for (int i = 1; i <= n / 2; ++i) {
cout << 2 * i << " " << 2 * i - 1 << ' ';
}
cout << '\n';
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int _ = 1;
cin >> _;
while (_--) {
solve();
}
return 0;
}
在这最近的两个月，我决定自己做一些项目（做了两个）来加深自己对程序员的理解、了解工程思维。最初我想的是，既然我用得最多的是 C++，那不妨就用 C++ 实现自己的宏图。但可惜第一关都差点过不了——最初我用的是 Visual Studio，目的是写一个贪吃蛇，可才写到一半准备编译排查语法错误时，神奇的事情发生了：由于 Unicode 字符的原因，导致它不能正确识别我的代码。那没辙，就准备在 VS Code 写。这下确实没有 UTF-8 格式的困扰了，可是又出了问题——需要用 #include <windows.h>，但我是在 WSL 下的，报错了。行吧，取消 WSL，可还是发生了意外：的确没有格式的烦恼了，但 C++ 无法正确识别 Unicode，输出乱码了。不得已，我回到了 Visual Studio，去调用 Windows 系统的 API，才最终解决。
我是性情中人，被 C++ 惹生气了，决定用我擅长的另一门语言——Rust 来重构。那为什么选择 Rust 呢？我会 C/C++、Rust、Python，由于上面的经历，我优先考虑 Rust 和 Python。它们有两个好处——安全：一个有 GC，一个有 Ownership。虽然我也用 Python 做过一些项目，不得不说的确方便，可是我有性能洁癖，再加上 Rust 的语法也很简洁，以及 Rust 的「能编译就一定安全」的语法检查，不仅对人类减少了心智负担，还对 AI 也很友好。我在网上查了一下相关的 Rust 代码作为借鉴。不过用 Rust 的确改变了我一个习惯，那就是拆分文件。因为用 C++ 写题惯了，经常一个文件几百行甚至几千行，看着不多，可这些都是个人文件，只有我一个人管理。
egui 应该是我的梦中情框架，为什么？因为它是纯 Rust 实现的。如果你了解过我，就会发现我的代码风格就是 Rust 的标准风格，哪怕写 C++，也是这个风格。为什么要用这个框架？原因很简单——我想做一个电子版便利贴（现已发布：https://github.com/summerTBD/SimpleNote）。在整个过程中，我感受最深的一点是：构思的重要性。我要实现想象中的功能，就得先确定很多事情——怎么触发、UI 界面是什么样的。其次就是，学习模板代码是怎么实现的，看多了就有思路了。但光有思路还不行，还需要动手操作，让身体和大脑做到协同。
]]>版本：0.7.0
设计哲学：显式、正交、无魔法。无必要不增实体。自由优先，安全可选。
编译目标：转译至 C（原型阶段），最终目标为自举并直接生成机器码。
self。try、方法调用）都可通过明确的脱糖规则还原为基础语法。defer），但绝不替你作主。以下为保留关键字，不可用作标识符。
1
2
3
4
5
6
const var fn struct enum match
if else while for return yield break continue
defer import pub extern
as parse null true false
and or not
test macro comptime asm global move
由字母、数字、下划线组成，必须以字母或下划线开头。不允许数字开头。
42，十六进制 0x2A，八进制 0o52，二进制 0b101010，可加下划线 1_000_000。3.14，1.0e-9。\n、\t、\\、\"，类型为 []const u8。true、false。null，类型可赋值给任意 *T / *mut T 以及 &T / &mut T。()，类型 unit。运算符及其优先级见附录。
逻辑运算符（Python 风格）：and or not（关键字）
位运算符：& | ^ ~
引用运算符：& &mut
分隔符：{ } ( ) [ ] ; , . => : ..
// 至行尾。/* ... */，可嵌套。if 作为语句时等，不产生值。return 右值、match 臂等，必须用 yield（块内）或 return（函数）提供值。语句必须以分号结尾。表达式语句、变量声明、赋值、return、yield、defer、global、move 均需分号。块 {} 之后通常不加分号，除非块作为表达式语句的一部分。
1
2
3
4
5
6
7
8
// 不可变变量（默认）
const x: i32 = 10;
const y = 20; // 类型推导
// 可变变量
var counter: i32 = 0;
counter = 1; // 允许重新赋值
x = 5; // 错误：不可变变量不可赋值
const 声明必须初始化，且后续不可修改绑定。var 声明允许重新赋值，但类型必须匹配。Vox 支持跨作用域遮蔽（内层作用域可以声明与外层同名的变量），但禁止同作用域重复声明。
1
2
3
4
5
6
7
8
9
var x: i32 = 5;
// 跨作用域遮蔽：允许
if cond {
var x: f64 = 3.14; // 合法：新作用域，新变量
}
// 同作用域重复声明：禁止
var x: i32 = 10; // 错误：标识符 'x' 已在当前作用域声明
设计理由：同作用域遮蔽会使旧变量隐式”消失”，与显式原则相悖。若需要重新绑定，请使用新名字或块表达式隔离中间变量。
const 若无循环依赖，应在编译期求值，值存入只读数据段。var 在进入 main 前初始化，初始化顺序按依赖拓扑排序。跨模块的可变全局状态由程序员自行保证同步安全。global)默认情况下，函数内部无法直接读写模块顶层的变量——它们必须被显式引入。
使用 global 语句可以解除这一限制：
1
2
3
4
5
6
7
8
9
10
11
12
// 模块顶层
var counter: i32 = 0;
fn increment() {
global counter; // 声明我要用外部的 counter
counter = counter + 1;
}
fn read_counter() -> i32 {
global counter;
return counter;
}
批量声明：可以在一个 global 语句中声明多个变量，用逗号分隔。
1
global counter, MAX, app_name;
规则：
global 只能用于当前模块顶层已声明的 const 或 var。global 修改 const 变量。math.PI）使用模块路径访问，不需要 global。global 声明，直接对与全局变量同名的标识符赋值，将视为对未定义变量的错误。global 声明本身不分配内存，不产生任何运行时开销——它是纯粹的编译期名字绑定指令，翻译后消失。move 赋值Vox 通过 move 关键字提供显式的所有权转移。赋值默认是复制（仅对纯数据安全），当需要将资源的所有权从一个变量转移到另一个变量时，使用 move：
1
2
3
var a = BigData { ... };
var b = move a; // ✅ 显式所有权转移
print(a); // ❌ 编译错误：a 的所有权已被 move
move 是一个表达式操作符，产生被移变量的值。详细语义见第 11 节。
| 类型 | 描述 |
| :— | :— |
| i8、i16、i32、i64 | 有符号整数 |
| u8、u16、u32、u64 | 无符号整数 |
| f32、f64 | 浮点类型 |
| bool | 布尔型 (true, false) |
| unit | 单元类型，字面量 ()，仅一个值 |
[T; N]，详见第 13 节。[]T 和 []const T，详见第 13 节。&T（不可变引用）、&mut T（可变引用）。详见第 10 节。*T（指向不可变数据）、*mut T（指向可变数据）。另见第 12 节。struct { ... }，详见第 8 节。enum Name { Variant1, Variant2(负载类型), ... }，详见第 9 节。标准库定义 Option<T> 枚举：
1
2
3
4
enum Option<T> {
Some(T),
None,
}
任何可能缺失的值应使用 Option<T> 表达。
as 操作符：用于安全的位模式转换或数值宽化/窄化。"123" as i32 是编译错误。parse 函数：将字符串解析为数值，返回 Result<T, ParseError>。允许在初始化时省略类型标注，推导范围限定为局部变量和函数返回值。函数参数必须显式标注。
1
2
3
fn add(a: i32, b: i32) -> i32 {
return a + b;
}
return 提供返回值。return，否则编译错误。var（例如 fn change(var x: i32)）。可从第一个 return 语句推导返回类型，但推荐显式标注。
当函数参数超过 3–4 个时，推荐将相关参数组织进一个结构体：
1
2
3
4
5
6
7
8
9
struct Config {
host: []const u8,
port: u16,
timeout: u32,
}
fn connect(cfg: Config) -> Result<Connection, Error> {
// ...
}
这种方式显式、自文档化，且不引入任何额外运行时开销。
if 表达式 / 语句if 可作为语句或表达式，取决于所处语境。
else。if 必须包含 else，且每个分支必须用 yield 提供值。1
2
3
4
5
6
7
8
9
10
11
// if 作为表达式
var status = if cond {
yield 1;
} else {
yield 0;
};
// if 作为语句
if flag {
do_work();
}
while 循环（语句）while 是语句，不返回值。
1
2
3
4
5
6
7
8
9
while i < 10 {
i = i + 1;
if i == 5 {
continue;
}
if i == 8 {
break;
}
}
for 循环（语句）for 也是语句，不返回值。
1
2
3
4
5
6
7
for item in collection {
print(item);
}
for var idx in 0..len {
arr[idx] = idx;
}
迭代变量默认 const，如需可变用 for var。break 和 continue 可用标签。
break / continue1
2
3
4
5
6
7
'outer: for i in 0..10 {
for j in 0..10 {
if matrix[i][j] == target {
break 'outer;
}
}
}
yield 表达式用在求值语境下的内嵌块（if/match/独立块）中，提供块的值并退出该块。
yield，编译错误。1
2
3
4
var x = {
var temp = compute();
yield temp + 1;
};
该块必须在所有出口用 yield 提供值。
1
2
3
4
5
6
7
8
9
struct Point {
x: f64,
y: f64,
}
// 方法定义：第一个参数显式为 self
fn Point.length(self: &Point) -> f64 {
return sqrt((self.x * self.x + self.y * self.y) as f64);
}
Type.method() 调用。self。self 参数可以是 &T（不可变方法）、&mut T（可变方法）或 *T / *mut T（底层指针方法）。p.length() 脱糖为 Point.length(&p)。self: &mut T：
1
2
3
fn Point.set_x(self: &mut Point, val: f64) {
self.x = val;
}
1
2
3
4
enum OptionInt {
Some(i32),
None,
}
变体可携带负载类型。
match 表达式match 是表达式，必须位于求值语境或作为语句都可以（语句时各分支可无 yield）。yield 提供值。1
2
3
4
5
6
7
8
var result = match opt {
Some(v) => {
yield v * 2;
}
None => {
yield 0;
}
};
Vox 提供两种引用类型，与裸指针并列但自带编译器安全检查（借用检查）：
| 类型 | 含义 | 可读 | 可写 |
|---|---|---|---|
&T |
不可变引用 | ✅ | ❌ |
&mut T |
可变引用 | ✅ | ✅ |
*T |
不可变裸指针 | ✅（不检查） | ❌ |
*mut T |
可变裸指针 | ✅（不检查） | ✅（不检查） |
引用的核心契约：”借用”——你暂时借走访问权，但不拥有数据，用完后必须归还。
1
2
3
4
5
6
7
8
9
10
const data: i32 = 42;
// 创建引用
const r: &i32 = &data; // 不可变引用
var val: i32 = 10;
var rm: &mut i32 = &mut val; // 可变引用
// 解引用
var x: i32 = *r; // 通过引用读取
*rm = 99; // 通过可变引用写入
&expr 创建不可变引用，&mut expr 创建可变引用。* 用于通过引用访问其所指向的值。&arr[0..3] 的类型是 &[]i32。编译器强制以下规则，确保引用不会导致数据竞争或悬空访问：
规则 1（读写分离）：任意时刻，对于一个值，要么存在任意多个 &T 引用，要么存在唯一一个 &mut T 引用，不能同时存在。
1
2
3
4
5
6
7
8
var data: i32 = 42;
const a: &i32 = &data; // ✅ 不可变引用 1
const b: &i32 = &data; // ✅ 不可变引用 2（与 a 共存）
print(*a, *b); // ✅ 多个只读读者，安全
var c: &mut i32 = &mut data; // ❌ 编译错误：已有不可变引用活跃
*c = 99;
1
2
3
4
5
6
var data: i32 = 42;
var rw: &mut i32 = &mut data; // ✅ 唯一可变引用
*rw = 99;
const r: &i32 = &data; // ✅ 此时 rw 已不再使用，可创建新的不可变引用
规则 2（原值冻结）：当 &mut T 引用存在且活跃时，原值被冻结——不可通过原值路径读或写。
1
2
3
4
5
var data: i32 = 42;
var rw: &mut i32 = &mut data; // rw 借走了 data 的可变访问权
print(data); // ❌ 编译错误：data 已被可变借用冻结
*rw = 99; // ✅ 只能通过借用者访问
规则 3（存活期不超过被借者）：引用的生命周期不能超过被引用变量的生命周期。
1
2
3
4
5
6
7
8
var r: &i32; // 声明一个引用变量
{
var local: i32 = 10;
r = &local; // ❌ 编译错误：local 离开作用域后 r 将悬空
}
print(*r);
| 场景 | 推荐使用 | 理由 |
|---|---|---|
| 想要编译器保障安全 | &T / &mut T |
借用检查器防止悬空和数据竞争 |
| 需要指针运算 | *T / *mut T |
引用不提供算术运算 |
| 与 C 代码交互 | *T / *mut T |
直接映射 C 指针 |
| 实现自定义分配器 | *mut T |
底层内存操作需要完全控制 |
| 对 null 语义的需求 | *T / *mut T |
引用不可为 null |
引用和裸指针可以自由互转——这种转换是显式的，编译器不做隐藏的转换：
1
2
3
4
const data: i32 = 42;
const r: &i32 = &data;
const p: *i32 = r as *i32; // 引用 → 裸指针：显式转换
const r2: &i32 = &*p; // 裸指针 → 引用：需确保此时 p 仍有效
引用可以作为函数参数和返回值类型：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
// 读取值（不可变借用）
fn get_value(data: &i32) -> i32 {
return *data;
}
// 修改值（可变借用）
fn increment(data: &mut i32) {
*data = *data + 1;
}
// 返回引用
fn first(arr: &[i32]) -> &i32 {
return &arr[0];
}
多个引用参数时的生命周期省略规则（由编译器自动推断，无需手动标注）：
方法定义时，self 参数的类型决定了该方法是否允许修改结构体：
1
2
3
4
5
6
7
8
9
10
11
12
13
struct Counter {
value: i32,
}
// 不可变方法：只能读取
fn Counter.read(self: &Counter) -> i32 {
return self.value;
}
// 可变方法：可以修改
fn Counter.add(self: &mut Counter, delta: i32) {
self.value = self.value + delta;
}
引用和 defer 是两个独立的机制，各司其职：
&T / &mut T）：管理”访问权”——谁能读、谁能写、能借用多久。defer：管理”资源”——文件、堆内存、锁等资源何时释放。两者互补，互不替代：
1
2
3
4
5
6
7
8
9
fn process_with_resource() {
var buf: *mut u8 = alloc.allocate(1024);
defer alloc.deallocate(buf); // defer 管释放
var view: &[]u8 = &buf[0..512]; // 引用管访问安全
process(view);
// view 超出作用域，借用结束
// 但 buf 直到函数退出才由 defer 释放
}
引用在转译到 C 时，直接映射为同类型的指针，零运行时开销：
| Vox | C |
|---|---|
&T |
T*（const 限定，若原类型不可变） |
&mut T |
T* |
&expr |
&expr（C 的取地址） |
*r（解引用） |
*r（C 的解引用） |
借用检查是纯编译期机制，转译后完全消失，不影响生成的 C 代码。
Vox 引入显式所有权转移（move 语义），与引用借用规则（第 10 节）共同构成完整的所有权体系：
1
2
3
引用（&T / &mut T） → 借用：暂时借走访问权，用完归还
move 转移 → 转让：永久转让所有权，原变量失效
赋值（=） → 复制：仅对安全类型（纯数据）允许
move 关键字是 Vox 设计哲学的延续——所有所有权操作在代码字面上显式可见。
move 表达式move 是一个一元表达式操作符，将其操作数变量的所有权转移到新变量：
1
2
3
4
var data: [i32; 5] = [1, 2, 3, 4, 5];
var transferred = move data; // data 的所有权转移到 transferred
print(data[0]); // ❌ 编译错误：data 已被 move，不可再使用
print(transferred[0]); // ✅ 转移后的变量正常可用
move 的可见效果：
move 是一个纯编译期概念，不产生任何运行时操作——它只改变编译器对变量活跃状态的跟踪。var b = a 不隐含 move 语义。这与 Rust 不同，是设计上的主动选择：
1
2
3
var a = SomeStruct { x: 10 };
var b = a; // ✅ 当前：复制语义（a 仍有效）
var c = move a; // ✅ move 语义（a 失效）
理由：如果 var b = a 这行字面上没有说 a 会失效，那么 a 就不应该失效。”显式优于隐式”原则要求：所有权转移必须通过 move 关键字明确表达。
并非所有类型都允许隐式复制。编译器根据类型是否包含资源自动判断：
| 类型类别 | 示例 | 隐式复制 var b = a |
|---|---|---|
| 原始类型 | i32, f64, bool, unit |
✅ 允许 |
| 纯数据 struct（无指针、无资源） | struct Point { x: f32, y: f32 } |
✅ 允许 |
| 定长数组（元素为可复制类型） | [i32; 10] |
✅ 允许 |
| 带指针字段的 struct | struct Node { data: *mut u8 } |
❌ 禁止（编译器报错） |
带 defer 资源的类型 |
函数内持有 defer free(p) 的变量 |
❌ 禁止（编译器报错） |
| 引用类型 | &T, &mut T |
✅ 允许（引用是 Copy 的） |
| 切片 | []T, []const T |
❌ 禁止（胖指针涉及数据引用） |
当编译器禁止隐式复制时，程序员必须使用 move 或显式 .clone()：
1
2
3
4
5
var buf: *mut u8 = alloc.allocate(1024);
defer alloc.deallocate(buf); // 资源类型
var other = buf; // ❌ 编译错误：不能隐式复制资源类型
var other = move buf; // ✅ 所有权转移
move 在函数参数传递中move 也可用于函数调用时显式转移所有权：
1
2
3
4
5
6
7
8
9
fn consume(data: *mut u8) {
// 函数获得所有权
defer alloc.deallocate(data);
process(data);
}
var buf: *mut u8 = alloc.allocate(1024);
consume(move buf); // ✅ 显式转移所有权给函数
print(buf); // ❌ 编译错误：buf 已被 move
函数参数默认不转移所有权——传参默认是复制（对允许复制的类型）或编译错误（对资源类型）。需要转移时必须显式使用 move。
move 在返回值中从函数返回变量时，若变量是资源类型，编译器要求：
1
2
3
4
5
fn create_buffer() -> *mut u8 {
var buf = alloc.allocate(256);
defer alloc.deallocate(buf); // 不，defer 会在 return 时执行！
return buf; // ❌ 编译错误：defer 会在 return 前释放 buf
}
正确写法：资源类型的返回必须通过 move 解除 defer 绑定：
1
2
3
4
fn create_buffer() -> *mut u8 {
var buf = alloc.allocate(256);
return buf; // 无 defer：返回所有权，由调用者负责释放
}
编译器规则：若变量有活跃的 defer 资源释放，则不可被返回或 move 到函数参数中。
move 与引用的交互一个变量在被借用期间不能 move：
1
2
3
var data: i32 = 42;
var r: &i32 = &data; // 借用 data
var moved = move data; // ❌ 编译错误：data 已被借用（引用 r 活跃）
当借用结束时（引用不再使用），可以 move：
1
2
3
4
5
6
var data: i32 = 42;
{
var r: &i32 = &data; // 借用开始
print(*r);
} // 借用结束，r 超出作用域
var moved = move data; // ✅ 此时可以 move
move 的转译策略（到 C）move 是纯编译期概念，在转译到 C 时完全不产生额外代码。它只影响编译器的变量活跃分析：
| Vox | C 效果 |
|---|---|
var b = move a; |
编译器不再允许后续对 a 的访问；生成的 C 代码中 b 接管了 a 的所有引用 |
consume(move buf); |
生成的 C 代码中，buf 变量在函数调用后不再被引用 |
return buf; |
生成的 C 代码等同于普通返回 |
引用检查（借用规则）和所有权跟踪（move）都是纯编译期机制，转译后完全消失，不影响生成的 C 代码。
move 与 lambda 捕获move 在 lambda 捕获中也有对应语义——见第 19.4.5 节。
*T：指向不可变数据的指针。*mut T：指向可变数据的指针。+、-（步长为指向类型大小），* 解引用。null，用 null 字面量产生空指针。标准库提供分配器对象 std_heap，底层为 malloc/free 映射。
1
2
3
var alloc = std_heap;
var mem: *mut u8 = alloc.allocate(1024);
defer alloc.deallocate(mem); // 作用域出口自动释放
defer 语句defer 后跟函数调用或块，在所在作用域退出前按后进先出顺序执行。纯编译期语法糖，零运行开销。
1
2
3
4
5
6
7
8
fn process() {
var f = open("data.txt");
defer close(f);
var mem = alloc.allocate(256);
defer alloc.deallocate(mem);
// 无论函数如何退出，两个 defer 都会逆序执行
}
Vox 提供渐进式安全，程序员可以自由选择安全级别：
| 级别 | 使用方式 | 保护程度 | 适用场景 |
|---|---|---|---|
| 安全 | &T / &mut T + defer |
高（编译器检查） | 业务逻辑 |
| 中等 | &T / &mut T + 手动管理 |
中（只防悬空引用） | 性能敏感区 |
| 自由 | *T / *mut T + defer |
低（程序员保证） | 底层系统编程 |
| 裸 | *T / *mut T |
无（完全手动） | 自定义分配器、FFI |
语言本身不强制任何安全级别，程序员通过选择类型来选定保护程度。未来可通过编译选项全局收紧安全检查。
[T; N]1
2
3
var arr: [i32; 5]; // 声明，未初始化
var arr: [i32; 5] = [1, 2, 3, 4, 5]; // 声明并初始化
const arr = [1, 2, 3]; // 类型推导为 [i32; 3]
访问：
1
2
arr[0] = 10;
var x = arr[1];
[]T 和 []const T1
2
var slice: []i32 = arr[0..3]; // 可变切片，可修改元素
var view: []const i32 = arr[0..3]; // 不可变切片，只读
"hello" 的类型为 []const u8。[]T 的元素可修改，[]const T 的元素只读。arr[start..end] 返回一个切片，左闭右开。可通过引用来借用切片的访问权，遵循借用规则：
1
2
3
4
5
var data: [i32; 5] = [1, 2, 3, 4, 5];
const full: &[i32] = &data; // 对整个数组的不可变引用
const part: &[i32] = &data[1..4]; // 对切片子集的不可变引用
var mut_part: &mut [i32] = &mut data[0..2]; // 可变引用
Vox 提供两个内置符号用于基本的控制台交互。它们不是关键字，而是编译器自动导入的函数。
1
2
3
print("Hello, ");
print("World!\n");
print("The answer is ", 42, "\n");
print 接受任意数量的参数，按顺序输出到标准输出。[]const u8、整型、浮点型或布尔型。\n 显式控制。1
var line = input();
input() 从标准输入读取一行，返回 []const u8。parse 函数：1
var n = parse(input()) as i32;
print 和 input 在转译到 C 时，直接映射到 C 标准库的 printf / puts 和 fgets，无额外运行时开销。
文件即模块：每个 .vox 文件就是一个模块。
pub 关键字：声明公有符号（函数、类型、变量）。import 语句：导入其他模块。示例：
1
2
3
4
5
6
7
8
9
// math.vox
pub const PI = 3.14159;
pub fn surface(r: f64) -> f64 {
return PI * r * r;
}
// main.vox
import math;
print(math.surface(10.0));
import module_name，之后使用 module_name.member 访问。import math.geometry 查找 math/geometry.vox。标准库定义 Result<T, E> 枚举：
1
2
3
4
enum Result<T, E> {
Ok(T),
Err(E),
}
Result。try 操作符（语法糖），若表达式结果为 Err 则立即从当前函数返回该错误：1
2
3
4
fn read_config() -> Result<Config, Error> {
var data = try read_file("config.json");
return parse_config(data);
}
1
2
3
4
extern "C" {
fn printf(format: *const u8, ...) -> i32;
fn malloc(size: usize) -> *mut u8;
}
*T 直接对应 C 指针。&T 也映射为 C 指针（纯编译期抽象，零开销）。使用 test 块编写单元测试：
1
2
3
4
5
6
7
test "add positive" {
const result = add(2, 3);
if result != 5 {
print("test failed");
return;
}
}
--test 标志将运行所有 test 块。test 块能访问模块私有函数。obj.method(args) 脱糖为 Type.method(&obj, args)（若 self: &T 或 self: *T）或 Type.method(&mut obj, args)（若 self: &mut T 或 self: *mut T）。
a[b] 脱糖为 a.at(b)（若用于读取）或 a.at_mut(b)（若用于赋值）。因此自定义类型只需实现 at / at_mut 方法即可支持下标语法。
try 表达式try expr 脱糖为：
1
2
3
4
match expr {
Ok(val) => val,
Err(e) => return Err(e),
}
Lambda 是纯编译期语法糖，转译到 C 后有明确的映射规则。现代 C 编译器优化能力极强，闭包结构体和函数指针调用通常可被完全内联优化，最终二进制等价于手写 C。
Lambda 使用 fn 关键字定义，可选捕获列表声明对外部变量的捕获方式。
捕获列表 [...] 位于参数列表之前，可包含默认捕获关键字和变量捕获项：
| 写法 | 含义 |
|---|---|
[copy] |
默认值捕获——lambda 体内所有用到的外部变量以副本形式捕获 |
[ref] |
默认引用捕获——lambda 体内所有用到的外部变量以引用形式捕获 |
[move x] |
指定 x 以所有权转移方式捕获（x 的所有权移入闭包） |
[base] |
指定 base 以值捕获 |
[&config] |
指定 config 以不可变引用捕获 |
[&mut counter] |
指定 counter 以可变引用捕获 |
[] 或无捕获列表 |
不捕获任何外部变量（纯函数） |
默认捕获关键字和变量捕获项可混合使用，变量项覆盖默认值：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
// 无捕获列表 — 纯函数
var f = fn (x: i32) -> i32 { return x * 2; };
// 指定捕获
var g = fn [base] (x: i32) -> i32 { return x + base; }; // 值捕获
var h = fn [&config] () -> i32 { return config.value; }; // 引用捕获
var i = fn [&mut counter] () -> i32 { counter = counter + 1; }; // 可变引用捕获
// 所有权转移捕获
var resource: *mut u8 = alloc.allocate(1024);
var k = fn [move resource] () -> void { // resource 所有权移入闭包
defer alloc.deallocate(resource);
};
// 默认捕获关键字（编译器推断捕获哪些变量）
var j = fn [copy] (x: i32) -> i32 { return x + base + counter; }; // 默认全部值捕获
var l = fn [ref] () -> i32 { return config.value + counter; }; // 默认全部引用捕获
// 混合：默认 + 个别覆盖
var m = fn [ref, timeout] () -> i32 { // 默认引用，但 timeout 值捕获
return config.value + timeout;
};
var n = fn [copy, &mut counter] () -> i32 { // 默认值拷贝，但 counter 可变引用捕获
counter = counter + config.step;
return counter;
};
var o = fn [copy, move resource] () -> void { // 默认值拷贝，但 resource 所有权转移捕获
process(resource);
alloc.deallocate(resource);
};
规则：
copy/ref）、name（值捕获）、&name（不可变引用捕获）、&mut name（可变引用捕获）或 move name（所有权转移捕获）。copy 或 ref），且必须位于列表首位。[...] 或 []），lambda 体内只能使用参数和局部变量，不能引用外部变量。[copy]/[ref]）是一种可控的隐式：捕获的变量列表由编译器根据 lambda 体自动推断，但捕获方式由程序员显式指定。当 lambda 没有捕获列表（不捕获任何外部变量）时，转译为独立的 C 函数，类型映射为函数指针。
1
2
var f = fn (x: i32) -> i32 { return x * 2; };
var result = f(21);
1
2
3
int32_t lambda__1(int32_t x) { return x * 2; }
int32_t (*f)(int32_t) = &lambda__1;
int32_t result = f(21);
零运行时开销——调用方式与直接函数调用完全一致。
当 lambda 按值捕获外部变量时，编译器生成：
struct Closure），捕获变量的副本作为其字段；Closure* 作为首个参数（环境指针）。1
2
3
var base = 10;
var f = fn [base] (x: i32) -> i32 { return x + base; };
var result = f(5);
1
2
3
4
5
6
7
8
9
10
11
12
// 闭包结构体
struct Closure__1 { int32_t base; };
// 调用函数（首参数为环境指针）
int32_t lambda__1(struct Closure__1* env, int32_t x) {
return x + env->base;
}
// Vox 脱糖
int32_t base = 10;
struct Closure__1 __env_1 = { .base = base };
int32_t result = lambda__1(&__env_1, 5);
当 lambda 通过引用捕获外部变量时，闭包结构体中存储指向外部变量的引用（&T 或 &mut T）而非值副本。
1
2
3
4
5
var counter = 0;
var f = fn [&mut counter] () -> i32 {
counter = counter + 1;
return counter;
};
1
2
3
4
5
6
struct Closure__1 { int32_t* counter; }; // &mut T → T*
int32_t lambda__1(struct Closure__1* env) {
*(env->counter) = *(env->counter) + 1;
return *(env->counter);
}
引用捕获的 lambda 必须在其捕获变量的生命周期内使用，编译器在借用检查阶段验证这一点。
当 lambda 通过 move name 捕获外部变量时，变量的所有权从原作用域转移至闭包结构体。原变量在 move 后失效，闭包结构体成为该值的新所有者。
1
2
3
4
5
6
7
var resource: *mut u8 = alloc.allocate(1024);
defer alloc.deallocate(resource); // ❌ 编译错误：resource 被 move 到闭包，不能有 defer
var resource: *mut u8 = alloc.allocate(1024);
var cleanup = fn [move resource] () -> void {
defer alloc.deallocate(resource); // ✅ defer 在闭包内部，资源由闭包管理
};
1
2
3
4
5
6
7
8
9
10
11
12
struct Closure__1 { uint8_t* resource; };
void lambda__1(struct Closure__1* env) {
// defer 展开：函数退出时释放
// ... 函数体逻辑 ...
free(env->resource);
}
// Vox 脱糖
uint8_t* resource = malloc(1024);
struct Closure__1 __env_1 = { .resource = resource };
// resource 此后不可用
规则：
move 捕获的变量，在 lambda 创建后原变量失效，不得再使用。defer 绑定的资源释放，编译器检测到变量被 move 后，自动将 defer 从原作用域剥离（交由闭包管理）。Arena（区域分配器）是 Vox 内置的内存管理方案，提供零手动的批量分配与释放。Arena 的核心思想是：在同一作用域内分配的所有对象，在作用域退出时自动一次性释放。
Rc/Arc/Box 的选择焦虑。free / delete / deferfree 调用）arena 关键字就是显式声明”这段内存我托管”使用 arena 关键字声明一个 Arena 作用域：
1
2
3
4
5
6
arena {
var a = new MyStruct { x: 1, y: 2 };
var b = new MyStruct { x: 3, y: 4 };
process(a, b);
}
// a, b 在此自动释放，不需要写任何 defer 或 free
arena { ... } 是一个语句。new T { ... } 在当前的最近外层 Arena 中分配一个 T 类型的对象，返回指向该对象的指针（*T）。new 分配的内存被一次性释放。new 表达式new 是一个一元前缀表达式，在当前最近的外层 Arena 中分配内存：
1
2
3
4
5
6
7
8
9
10
// 分配结构体
var p = new Point { x: 1.0, y: 2.0 };
// 分配数组
var arr = new [i32; 10]; // 分配 10 个 i32 的数组，未初始化
var arr = new [i32; 10] { 0 }; // 分配并初始化全部为 0
// new 返回的是指针类型 *T
// 用 * 解引用访问
*p.x = 10;
当函数体最外层用 arena 包裹时，整个函数内所有 new 分配在函数退出时统一释放：
1
2
3
4
5
6
7
8
fn process() {
arena {
var temp = new Temp { ... };
var buf = new Buffer[256];
use(temp, buf);
}
// 函数返回时，temp 和 buf 自动释放
}
当需要从 Arena 中返回一个对象到外部时，使用 return 或 yield：
1
2
3
4
5
6
7
fn create() -> *MyStruct {
arena {
var obj = new MyStruct { x: 42 };
return obj; // obj 的所有权转移到调用者
// arena 内其他分配仍自动释放
}
}
编译器规则：
return 或 yield 从 Arena 中逃逸的对象，不被 Arena 释放。defer：独立且互补1
2
3
4
5
6
7
arena {
var f = open("test.txt"); // 不是 new 分配的，用 defer
defer close(f);
var buf = new [u8; 1024]; // arena 管理，不需要 defer
read(f, buf);
}
&/&mut：完全兼容1
2
3
4
5
arena {
var obj = new MyStruct { x: 1 };
var r: &MyStruct = &*obj; // 对 arena 中的对象创建引用
// 引用在 arena 结束前有效
}
new 返回 *T，直接对应 C 的指针，零开销。
Arena 在转译到 C 时，使用线性分配器模式：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
// Vox:
// arena {
// var a = new MyStruct { x: 1, y: 2 };
// var b = new MyStruct { x: 3, y: 4 };
// process(a, b);
// }
// 生成的 C:
{
void* __arena_begin = malloc(4096);
size_t __arena_pos = 0;
struct MyStruct* a = (struct MyStruct*)((char*)__arena_begin + __arena_pos);
__arena_pos += sizeof(struct MyStruct);
a->x = 1; a->y = 2;
struct MyStruct* b = (struct MyStruct*)((char*)__arena_begin + __arena_pos);
__arena_pos += sizeof(struct MyStruct);
b->x = 3; b->y = 4;
process(a, b);
free(__arena_begin); // O(1) 一次性释放
}
优化：对于总分配大小较小的 Arena（例如 < 4096 字节），编译器可以自动使用 alloca 在栈上分配，零堆分配、零释放：
1
2
3
4
5
6
7
{
// 对于小 Arena，使用 alloca 在栈上分配
void* __arena_begin = alloca(512);
size_t __arena_pos = 0;
// ... 同上 ...
// 不需要 free，函数返回时栈帧自动回收
}
Arena 是 Vox 首选的内存管理方案，覆盖了 90% 以上的场景：
| 场景 | Arena 能不能解决 |
|---|---|
| 临时对象（函数内） | ✅ Arena 块完美解决 |
| 请求级别的生命周期 | ✅ 函数级 Arena 解决 |
| 对象池 | ✅ Arena 是天然的池 |
| 复杂图结构（链表、树、图） | ❌ 节点生命周期不同，需配合手动管理 |
| 长期存活的对象 | ✅ 全局 Arena |
对于 Arena 无法优雅处理的场景（如交叉引用的图结构），未来版本可能引入可选的 GC，但 Arena 始终是 Vox 的内存管理基石。
new 关键字而非函数调用：new 在视觉上明确表示”这是堆分配”，与 C++ 的 new 语义对齐但更简单（不涉及构造函数）。new 返回指针而非引用：指针是最低开销的抽象，且与 C 的交互自然。需要安全访问时可以通过 &*ptr 转换为引用。new 在 Arena 块之外：这强制了 Arena 的显式性——如果你需要在 Arena 之外分配，说明你没有声明 Arena，编译器会报错。这是设计上的主动约束，防止忘记声明 Arena。alloca）或堆（malloc），程序员不需要关心这一实现细节。arena 是一个语句而非表达式：Arena 管理的是副作用（内存分配与释放），作为语句更符合直觉，且与 Vox 的求值/语句语境划分一致。（从高到低）
| 优先级 | 运算符 |
|---|---|
| 1（最高） | () 调用，[] 索引，. 字段访问 |
| 2 | -（一元负），~（按位取反），*（解引用），move |
| 3 | * / % |
| 4 | + - |
| 5 | << >> |
| 6 | & \| ^ |
| 7 | < <= > >= |
| 8 | == != |
| 9 | not（关键字） |
| 10 | and（关键字） |
| 11（最低） | or（关键字） |
赋值运算符 = 优先级低于 or，右结合。
范围运算符 .. 优先级低于赋值运算符。
一元取引用运算符 & / &mut 优先级同解引用（优先级 2）。
move 关键字而不是隐式 move：保持”显式优于隐式”原则的一致性。var b = a 如果不含有 move 关键字，则不应改变 a 的有效性。隐式 move（Rust 风格）虽然简洁，但使所有权转移变得不可见，与 Vox 的核心设计哲学冲突。namespace 块，一个实体只出现一次。return：保证求值语境的明确性。每条执行路径的意图都清晰可见。global 关键字：强制程序员在函数内显式声明对模块级变量的访问，避免不小心遮蔽或无意修改全局状态。该关键字是纯编译期指令，零运行时开销。print 不自动换行、不提供格式化占位符，所有行为由程序员显式控制。这符合”无魔法”原则。&T / &mut T 而非其他引用语法：Rust 风格的引用语法是最清晰的选择——& 符号在视觉上即表示”借取地址”，与解引用 * 形成对称。&T 与 &mut T 的区别在类型层面显式表达，一眼可读。&mut T 是对值的独占写入权——借出期间原值被冻结是引用的核心语义。”引用就真的是引用”，不是换了个名字的别名。参见第 10 节。*T / *mut T）并列，让程序员在安全和自由之间自由选择。and/or/not 而非 &&/||/!：消除”单 & 是位与还是逻辑与”的语义混淆。Python 方案将逻辑运算和位运算在语法层面彻底分离——逻辑运算用关键字 and or not，位运算用符号 & | ^ ~——程序员无需依赖优先级记忆，代码扫读时语义一目了然。此设计借鉴自 Python，也是”显式优于隐式”原则的自然延伸。v0.5.0 起生效。本手册随语言版本持续更新，当前版本为 v0.7.0。
]]>在一个单调数列中我们要去找第一个大于 target 的值（也可以是小于、小于等于、大于等于），我们往往会采用二分查找，它的时间复杂度很优秀，是 $O(\log n)$。但二分法有一个前提：我们必须知道数组的完整范围（即左右边界）。如果不知道数组究竟有多大，甚至数组是”无限”的（或我们只知道起点），二分法就无法直接使用。
此时有两种思路：
本文讨论的”倍增”正是这样一种思想：通过指数级扩大步长来快速定位目标范围。它在竞赛题中一个经典的应用就是下面这道题——AcWing 109。
现在我们的情况是并不知道整个数组的大小。第一步肯定要找到 target 的大致区间。那怎么找？我们定义一个指数 $p$，从当前位置往后数 $2^p$ 个位置。根据往后数到达的位置与 target 的关系决定 $p$ 是 p *= 2 还是 p /= 2。
讲到这里如果你对数字敏感的话，可以看出这其实是一个”奇怪的二分法”。为什么这么说呢？当我们碰到第一个需要 p /= 2 的时候，你会发现，我们其实在 cur_pos 和 cur_pos + (1 << p) 这个区间做二分查找。时间复杂度也是 $O(\log n)$，不过它其实比真正的二分慢，因为严格说它采用了 $2\log n$ 步，二分则是严格的 $\log n$。
给定一个整数 $M$，对于任意一个整数集合 $S$，定义”校验值”如下：
从集合 $S$ 中取出 $M$ 对数（即 $2 \times M$ 个数，不能重复使用集合中的数，如果 $S$ 中的整数不够 $M$ 对，则取到不能取为止），使得”每对数的差的平方”之和最大，这个最大值就称为集合 $S$ 的”校验值”。
现在给定一个长度为 $N$ 的数列 $A$ 以及一个整数 $T$。我们要把 $A$ 分成若干段，使得每一段的”校验值”都不超过 $T$。求最少需要分成几段。
输入格式
第一行输入整数 $K$，代表有 $K$ 组测试数据。 对于每组测试数据，第一行包含三个整数 $N, M, T$。 第二行包含 $N$ 个整数，表示数列 $A_1, A_2 \dots A_N$。
输出格式
对于每组测试数据，输出其答案，每个答案占一行。
数据范围
\[1 \le K \le 12,\quad 1 \le N, M \le 500000,\quad 0 \le T \le 10^{18},\quad 0 \le A_i \le 2^{20}\]输入样例：
1
2
3
4
5
2
5 1 49
8 2 1 7 9
5 1 64
8 2 1 7 9
输出样例：
1
2
2
1
如果我们已知整个数组只需要分成两段（即只有一个断点），那么我们可以直接二分这个断点的位置。但问题在于我们不知道有多少个断点，也无法直接确定每个区间应该从哪里切分——这正是倍增派上用场的地方。
具体来说，我们从左到右处理数组，每次用倍增法确定当前段的最长合法右边界：
这样做的时间复杂度为 $O(\log n)$ 次校验，而不是线性枚举的 $O(n)$ 次。
不过想必你一定还有一个疑问：如果按校验值的算法，每次都要给一个区间排序再算校验值，这个复杂度真的过得了吗？
答案是一般过不了。原因在于：对于 $[L, \text{mid})$ 我们要加入 $[\text{mid}, \text{right})$，如果每次都对整个 $[L, \text{right})$ 重新排序，复杂度会很高。但注意到这是一个插入有序区间的问题：$[L, \text{mid})$ 已经有序，我们只需要将 $[\text{mid}, \text{right})$ 排序后与它合并即可（归并），这样每次只需 $O(\text{len} \cdot \log \text{len})$ 的排序开销，而非对整个新区间重新排序。
因此我们需要两个辅助数组：
如果校验成功，则将 $\text{tmp}$ 写回 $t$；如果失败也没关系，虽然 $[\text{mid}, \text{right})$ 在 $t$ 中排了一次序，但后续的扩展会覆盖它，不会产生副作用。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 500005;
int n, m;
ll T;
ll a[N], t[N], tmp[N];
ll sq(ll x) {
return x * x;
}
// [l, mid), [mid, r)
bool check(int l, int mid, int r) {
for (int i = mid; i < r; ++i) {
t[i] = a[i];
}
sort(t + mid, t + r);
int i = l, j = mid, k = 0;
while (i < mid && j < r) {
if (t[i] < t[j]) {
tmp[k++] = t[i++];
} else {
tmp[k++] = t[j++];
}
}
while (i < mid) {
tmp[k++] = t[i++];
}
while (j < r) {
tmp[k++] = t[j++];
}
ll sum = 0;
int L = 0, R = k - 1;
for (int p = 0; p < m && L < R; ++p) {
sum += sq(tmp[R] - tmp[L]);
R--;
L++;
}
return sum <= T;
}
void solve() {
cin >> n >> m >> T;
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
int L = 0;
int ans = 0;
while (L < n) {
int R = L;
int len = 1;
t[L] = a[L];
while (len > 0) {
if (R + len <= n && check(L, R, R + len)) {
R += len;
len <<= 1;
// 把t给排好序，在check函数中，合并了t的两部分，这部分是
// 变成了tmp，但t本身没有被更新，所以这里需要把排好序的t更新回去
for (int i = L; i < R; ++i) {
t[i] = tmp[i - L];
}
if (R >= n) {
break;
}
} else {
len >>= 1;
}
}
ans += 1;
L = R;
}
cout << ans << "\n";
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int K;
cin >> K;
while (K--)
solve();
return 0;
}
https://codeforces.com/problemset/problem/2233/C
给定一个长度为 $n$ 的括号序列 $s$（由 ( 和 ) 组成），以及一个整数 $k$。Alice 可以删除至多 $k$ 个括号，她的目标是最小化剩余序列的最长合法括号子序列（LBS）的长度。换句话说，Alice 希望无论如何操作，对手都无法在剩下的序列中找到太长的合法配对。
我们的任务是：判断 Alice 是否存在一种删除方案，使得剩余序列的最长合法括号子序列的长度不超过某个下界（或者等价地，求出她能做到的最小代价）。
合法括号序列有一个基本的结构性质：任何合法的括号配对，左括号一定在对应的右括号之前。因此，如果我们想”破坏”尽可能多的配对，一个自然的想法是：
(，因为这些左括号最容易找到与之匹配的右括号；)，因为这些右括号最容易找到与之匹配的左括号。为什么这样做是最优的？考虑一对已经匹配的括号 $(i, j)$（$i < j$），其中 $s_i = \texttt{(}$，$s_j = \texttt{)}$。由于 $i$ 和 $j$ 在配对意义下是轮换对称的，我们只需关注其中一侧。假设我们删除了某个左括号 $s_i$，对手试图找一个 $i’ \neq i$ 来代替 $s_i$ 与 $s_j$ 配对。如果我们删除的是最左边的左括号，那么在它之前没有任何 ( 可以替代它——因此对手必然丢失这个配对，代价确定性地减少 1。同理，删除最右边的右括号也能保证同样的效果：在它之后没有任何 ) 可以替代它。
反过来，如果我们删除的是中间的某个括号，对手有可能在它的左侧找到另一个 (（或在右侧找到另一个 )）来顶替，从而维持原有的配对数量。当然，这并不总是成立——在某些序列中删除中间括号确实也会减少代价（例如 ((())) 中删除中间括号依然会破坏配对）。但问题在于：这种操作的收益依赖于序列的具体结构，我们无法保证每一次删除都能稳定地减少代价。相比之下，删除最左 ( 或最右 ) 是无条件保证代价减 1 的操作——无论序列长什么样，这个结论都成立。因此，最优策略必然选择后者。
结论：Alice 的最优策略一定是删除序列最左边的 $x$ 个 ( 和最右边的 $y$ 个 )，其中 $x + y \le k$。
设 $x$ 为删除的最左 ( 数量，$y$ 为删除的最右 ) 数量，满足 $0 \le x + y \le k$。对每一组 $(x, y)$，我们可以模拟删除后剩余序列的最长合法括号子序列长度：
(（即不将它们加入剩余序列）；)；open，遇到 ( 则 open += 1，遇到 ) 且 open > 0 则 match += 1, open -= 1。我们枚举所有合法的 $(x, y)$ 组合，取使得匹配数最小的那一组，即可得到 Alice 的最优代价。
设 $L$ 为 ( 的总数，$R$ 为 ) 的总数。$x$ 的取值范围是 $0 \sim \min(k, L)$，对于每个 $x$，$y$ 取 $\min(k - x, R)$。因此枚举量是 $O(k)$。每次模拟计算匹配数的复杂度是 $O(n)$。总复杂度 $O(kn)$，在题目给定的数据范围内可以通过。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
int n, k;
string s;
// 删除最左 x 个 '(' 和最右 y 个 ')' 后，计算剩余序列的最长合法括号子序列长度
int calculate_match(int x, int y) {
vector<char> kept;
int left_deleted = 0;
for (auto c : s) {
if (c == '(' && left_deleted < x) {
left_deleted += 1;
} else {
kept.emplace_back(c);
}
}
int right_deleted = 0;
for (int i = (int)kept.size() - 1; i >= 0 && right_deleted < y; --i) {
if (kept[i] == ')') {
kept[i] = '\0'; // 标记删除
right_deleted += 1;
}
}
int open = 0, match = 0;
for (auto c : kept) {
if (c == '\0') continue;
if (c == '(') {
open += 1;
} else if (open > 0) {
match += 1;
open -= 1;
}
}
return match;
}
// 构造具体的删除方案（1 表示删除，0 表示保留）
vector<int> generate_result(int x, int y) {
vector<int> res(n, 0);
int left_deleted = 0;
for (int i = 0; i < n && left_deleted < x; ++i) {
if (s[i] == '(') {
res[i] = 1;
left_deleted += 1;
}
}
int right_deleted = 0;
for (int i = n - 1; i >= 0 && right_deleted < y; --i) {
if (s[i] == ')') {
res[i] = 1;
right_deleted += 1;
}
}
return res;
}
void solve() {
cin >> n >> k >> s;
int total_left = 0, total_right = 0;
for (char c : s) {
if (c == '(') total_left++;
else total_right++;
}
int min_match = INF;
int best_x = 0, best_y = 0;
int max_x = min(k, total_left);
for (int x = 0; x <= max_x; ++x) {
int y = min(k - x, total_right);
if (y < 0) continue;
int match = calculate_match(x, y);
if (match < min_match) {
best_x = x;
best_y = y;
min_match = match;
}
}
auto result = generate_result(best_x, best_y);
for (auto x : result) cout << x;
cout << "\n";
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
本题的关键在于认识到：为了最大化破坏配对的效果，Alice 应当优先删除两端的括号——最左边的 ( 和最右边的 )。这个结论可以通过”被删除括号的可替代性”来论证：只有最左的左括号和最右的右括号是不可替代的，删除它们才能保证配对数量一定减少。在此基础上，枚举删除数量即可得到最优解。
设 \(k\) 是一个固定的正整数。对于任意整数 \(a\) 和满足 \(0 \le b < k\) 的整数 \(b\)，定义映射
\[f(a,b) = a \cdot k + b,\]证明 \(f\) 是单射（即不同的有序对 \((a,b)\) 对应不同的函数值）。
这是最经典的证明思路。
假设存在两对不同的 \((a_1, b_1)\) 和 \((a_2, b_2)\) 满足：
\[a_1 k + b_1 = a_2 k + b_2, \quad 0 \le b_1, b_2 < k.\]移项得：
\[(a_1 - a_2) k = b_2 - b_1.\]考虑右边 \(b_2 - b_1\) 的绝对值：由于 \(0 \le b_1, b_2 < k\)，必有
\[|b_2 - b_1| < k.\]| 左边 \((a_1 - a_2)k\) 要么为 \(0\)，要么绝对值至少为 \(k\)（因为 \(a_1 - a_2\) 是非零整数时，$$ | (a_1 - a_2)k | \ge k$$）。 |
因此等式两边必须同时为 \(0\)，即 \(a_1 - a_2 = 0\) 且 \(b_2 - b_1 = 0\)。故 \(a_1 = a_2,\; b_1 = b_2\)，与假设矛盾。得证。
结论：在条件 \(0 \le b < k\) 下（即 \(k\) 严格大于 \(b\) 的上界），映射 \((a,b) \mapsto a \cdot k + b\) 是单射。换言之，\(f\) 将不同的有序对 \((a,b)\) 映射到不同的整数值。
说实话，我第一次看到这个问题时，并没有想到反证法，而是想到了另一种做法——几何法。这受到了康托尔配对函数（Cantor pairing function） 的启发。
康托尔配对函数是一种将自然数对 \((x,y)\) 映射为单个自然数的方法，它通过将平面上的点按某种顺序”走遍”来构造。我们不妨也这样想：
把 \((a,b)\) 看成是一个矩形网格中的位置——\(a\) 是行号，\(b\) 是列号，而 \(k\) 是每一行的列数，且 \(0 \le b < k\) 保证了 \(b\) 始终落在有效的列范围内。
在这样一个网格中，将 \((a,b)\) 映射为”从第 0 行第 0 列开始，按行优先数到的序号”：
\[\text{index} = a \cdot k + b.\]现在来证明这个映射是单射。假设 \((a_1, b_1)\) 和 \((a_2, b_2)\) 映射到同一个序号 \(N\)，即
\[a_1 k + b_1 = N = a_2 k + b_2, \quad 0 \le b_1, b_2 < k.\]将 \(N\) 除以 \(k\)，由带余除法（Euclidean division） 的定理：对于任意整数 \(N\) 和正整数 \(k\)，存在唯一的整数商 \(q\) 和余数 \(r\)，满足
\[N = q \cdot k + r, \quad 0 \le r < k.\]由于 \(a_1 k + b_1\) 和 \(a_2 k + b_2\) 都满足这个形式，且 \(0 \le b_1, b_2 < k\)，由商和余数的唯一性即得 \(a_1 = a_2\) 且 \(b_1 = b_2\)。故映射为单射。
注：这个论证本质上与反证法相同，但几何视角让”行号/列号”与”商/余数”之间的对应关系变得更加直观。
此外还需要注意一个细节：若 \(k = b_{\max}\)，则 \(b = b_{\max}\) 时已不满足 \(0 \le b < k\) 的条件，此时映射不再是单射。例如 \((0, k)\) 和 \((1, 0)\) 就冲突：
\[0 \cdot k + k = k, \quad 1 \cdot k + 0 = k.\]这与网格中”每一行只有 \(k\) 列（编号 \(0\) 到 \(k-1\)）”的直观一致——\(k\) 已经是越界的列号了。
当我们用几何法思考时，你是否注意到一个现象：\(b\) 必须有一个最大值 \(b_{\max}\)。遍历到一行的末尾时，再往后就会”进位”到下一行。
这像什么？像进制数。
在十进制中，个位满了 10 就向十位进 1。类似地，在这里，\(b\) 满了 \(k\) 就向 \(a\) 进 1。
如果我们把 \((a,b)\) 看成一个 k 进制数，其中 \(a\) 是高位，\(b\) 是低位，那么：
\[a \cdot k + b\]就是它在十进制下的值。
于是，我们有了第三种视角——进制视角。下面给出 k 进制表示唯一性的一般证明。
定理：设 \(k \ge 2\) 为正整数。任意非负整数 \(N\) 可以唯一地表示为
\[N = a_m k^m + a_{m-1} k^{m-1} + \cdots + a_1 k + a_0,\]其中 \(m \ge 0\)，\(0 \le a_i < k\) 且 \(a_m \neq 0\)（当 \(N = 0\) 时，取 \(m = 0\)、\(a_0 = 0\)）。
证明（存在性）：反复使用带余除法。 令 \(N_0 = N\)。对 \(i = 0, 1, 2, \dots\) 依次执行
\[N_i = q_i \cdot k + r_i, \quad 0 \le r_i < k,\]并设 \(a_i = r_i\)、\(N_{i+1} = q_i\)。由于 \(N_{i+1} < N_i\)（当 \(N_i > 0\) 时），这个过程必在有限步后终止于 \(N_{m+1} = 0\)。此时
\[N = a_m k^m + a_{m-1} k^{m-1} + \cdots + a_0.\]证明（唯一性）：假设有两种表示
\[N = \sum_{i=0}^m a_i k^i = \sum_{i=0}^n b_i k^i,\]其中 \(0 \le a_i, b_i < k\)。不妨设 \(m \le n\)，并对不足的高位补零（即 \(i > m\) 时视 \(a_i = 0\)）。
考虑模 \(k\) 的同余式：
\[\sum_{i=0}^n a_i k^i \equiv \sum_{i=0}^n b_i k^i \pmod{k}.\]由于 \(k^i \equiv 0 \pmod{k}\) 对 \(i \ge 1\) 成立，上式化为 \(a_0 \equiv b_0 \pmod{k}\)。而 \(0 \le a_0, b_0 < k\)，故 \(a_0 = b_0\)。
两边同时减去 \(a_0 = b_0\) 后除以 \(k\)：
\[\sum_{i=0}^{n-1} a_{i+1} k^{i} = \sum_{i=0}^{n-1} b_{i+1} k^{i}.\]再次模 \(k\) 得 \(a_1 = b_1\)。以此类推，逐位可得 \(a_i = b_i\) 对 \(i = 0, 1, \dots, n\) 均成立。故表示唯一。∎
回到原问题：当我们将 \((a,b)\) 视为一个两位的 k 进制数时，上面的唯一性定理直接保证了映射 \(f(a,b) = a \cdot k + b\) 是单射。这正是进制视角的核心力量——它不仅解释了 \(a \cdot k + b\) 为什么是单射，还揭示了其本质：哈希值的运算（乘 k 再加 b）恰恰就是在做进制数的拼装。
将 \((a,b)\) 看作一个 k 进制数的两位数字（\(a\) 为高位，\(b\) 为低位），那么
\[a \cdot k + b\]就是它在十进制下的数值。这里的核心是进制表示的唯一性：在 k 进制中，每一位数字的取值范围是 \(0\) 到 \(k-1\)，不同的数码组合必然对应不同的数值。
换一个视角：表达式 \(a \cdot k + b\) 在形式上与一次多项式 \(p(x) = a x + b\) 相同。但需要特别注意的是，这里 \(k\) 是一个确定的数值而非未定的变元，因此不能直接套用”多项式恒等定理”（该定理要求等式对所有变元取值成立，而不仅在 \(x = k\) 这一个点成立）。然而，如果限制系数的取值范围，则数值等式可以推出系数相等——这正是反证法所证明的结论。换言之：
若 \(0 \le b_1, b_2 < k\) 且 \(a_1 k + b_1 = a_2 k + b_2\)，则 \(a_1 = a_2\) 且 \(b_1 = b_2\)。
这个结论并不依赖于多项式理论，而是依赖于 \(b\) 的取值范围约束。将表达式类比为多项式，只是为了帮助我们直观理解”系数唯一性”——但这需要以反证法或带余除法作为严格的逻辑基础。
| 与反证法的联系：在反证法的推导中，$$ | (a_1-a_2)k | < k \Rightarrow a_1 = a_2\(这一步骤的实质是：k 进制表示中，高位不同会导致数值差距至少为\)k$$，而低位差不足以弥补这一差距。 |
以上思路可以自然推广到更多参数。考虑三元组 \((a,b,c)\)，其中 \(0 \le b < k,\; 0 \le c < k\)，映射为
\[g(a,b,c) = a \cdot k^2 + b \cdot k + c.\]这可以看作是一个 k 进制三位数。下面用反证法证明其单射性。
假设存在两个不同的三元组 \((a_1,b_1,c_1)\) 和 \((a_2,b_2,c_2)\)（均满足 \(0 \le b_i, c_i < k\)）使得
\[a_1 k^2 + b_1 k + c_1 = a_2 k^2 + b_2 k + c_2.\]移项得
\[(a_1 - a_2)k^2 + (b_1 - b_2)k = c_2 - c_1.\]整理为
\[\big((a_1 - a_2)k + (b_1 - b_2)\big)k = c_2 - c_1.\]| 由于 \(0 \le c_1, c_2 < k\)，有 $$ | c_2 - c_1 | < k\(。而左边括号内是整数，记\)m = (a_1 - a_2)k + (b_1 - b_2)\(，则等式为\)m k = c_2 - c_1\(。因此\) | m | k < k\(，故\) | m | < 1\(，即\)m = 0$$。 |
于是 \(c_2 - c_1 = 0\)，且
\[(a_1 - a_2)k + (b_1 - b_2) = 0.\]这就回到了我们已经解决的二元情形。由反证法结论得 \(a_1 = a_2\) 且 \(b_1 = b_2\)。结合 \(c_1 = c_2\)，故 \((a_1,b_1,c_1) = (a_2,b_2,c_2)\)，与假设矛盾。得证。
更一般地，对于 \(n\) 元组 \((a_1, a_2, \dots, a_n)\)（满足 \(0 \le a_i < k\)，其中 \(i \ge 2\)，而 \(a_1\) 可为任意整数），映射
\[h(a_1, a_2, \dots, a_n) = a_1 \cdot k^{n-1} + a_2 \cdot k^{n-2} + \cdots + a_n\]是单射。可以用数学归纳法严格证明：当 \(n = 1\) 时结论平凡。假设对 \(n-1\) 元组成立，对 \(n\) 元组的情形，利用等式
\[(a_1 k^{n-1} + \cdots + a_{n-1} k + a_n) = \big((a_1 k^{n-2} + \cdots + a_{n-1})\big) \cdot k + a_n\]将其化归为 \((m, a_n)\) 的二元情形（其中 \(m = a_1 k^{n-2} + \cdots + a_{n-1}\)），再结合归纳假设即可。这从另一个角度印证了 k 进制表示的唯一性。
本文从一个简单的哈希映射问题出发，给出了三种不同视角的证明：
| 方法 | 核心思想 | ||
|---|---|---|---|
| 反证法 | 利用 $$ | b_2-b_1 | < k$$ 迫使系数相等，是最直接的证明 |
| 几何法 | 按行优先排列成矩形，通过带余除法的唯一性论证 | ||
| 进制数法 | 将 \((a,b)\) 视为 k 进制数，利用进制表示的唯一性 |
殊途同归——它们最终都指向同一个结论：只要 \(k\) 严格大于 \(b\) 的上界，\(a \cdot k + b\) 就是 \((a,b)\) 的一个完美哈希。
]]>为什么我会突然看这部动漫？其实这离我上一次看动漫不远，大概隔了一个月。你可能会说一个月还不远吗？那如果我说，上一次离上上次隔了一年呢？其实，在昨天我已经看了一部分，但是今天我又从头看了一遍。
在昨天，我发现《关于我转生成史莱姆这档事》出了第4季，其实我还没有动力去看，因为它第三季我都没看过。那我为什么突然想看了呢？如果注意博客发布时间，就知道我是发布完博客，才看的。我发布一篇博客后，我心血来潮，我问 AI 你觉得 https://summertbd.github.io/ 这个人的博客怎么样，它回答的八九不离十，但有被骗的经历，我决定问一个刁钻的问题，我的头像的人物是谁，他说是 Shion，我看他的思考过程和他给的答案，我恍惚了，到现在我还是不能释怀。我的确用过这个动漫的头像，但不是 Shion，是利姆露，我现在用的是超时空辉夜姬的彩叶，那一瞬间我想再去看一眼这个我当初说要追到底的动漫。
读者可能不知道，这个时间节点，我才大一，这部动漫是我初中看的，而高中三年，我的少年心气似乎没了。我当初毕业，我是这么跟朋友说的，”初中到高中，我从稚嫩到了成熟，到大学，我一定从成熟到幼稚”。对不起，我没有做到，当我意识到时，我发现我的人生是一个骗局，我说我要重拾少年心气，我没有做到，我说我不要在这么煎熬地向前，我没有做到，我看着别人前进，我无法做到冷静，我还是会打破我的节奏。
当我重新看这部动漫的时候，我想直接看第四季，但是发现我的记忆有点跟不上，我就从第三季开始，虽然还是有点记忆缺失，但我不愿意从第二季开始。我最喜欢的是第一季，但与第二季的拖沓和第一季的不拖泥带水相比，我被恶心了好一阵子，我都忘了我有没有看完第二季，但那不重要了。
最重要的不是它有多好，而是它有多烂。为什么这么说呢？其实这个动漫，我觉得作者没把我当人。他就像一群孩子过家家，它的套路有时候看着很牵强，有时候没有什么逻辑，有时候完全不符合常理。我一边骂作者没把我当人，觉得这个剧情好尬，一边又继续看下去。我当时是怎么看下去的？我也不知道。我就是想继续看下去的。我对逻辑其实很挑的，如果我发现有一处逻辑不严谨，其实我就很容易看不下去，但是我就是看下去了。
当时的我又是怎样的呢？当我照向镜子，我发现我不是我，我不是我眼中的我。
我想，这部作品虽然儿戏，但我想这就是动漫的力量。影视作品不会告诉你，你该怎么做，他只会给你讲一个故事，一个打动你的故事。我有多久是为了看动漫而看动漫，是为了休息而休息，而不是为了更好的工作而休息。我有多久没有见到我自己了，我的身体不是我灵魂的身体，我的灵魂不是我身体的灵魂。
这部动漫，是如此让我尴尬，可这不就是我看下去的理由。
我想我的精神老了，他需要的不是养老，而是一场复活。一场由死到生的复活。
]]>在《算法竞赛进阶指南》中，奇数码问题（奇数阶数码推盘）的可达性条件通常只给出必要性证明——任何合法移动不改变逆序对奇偶性；充分性的证明常被省略或依赖繁杂的分情况构造。本文记录一个利用棋盘旋转对称性将上下移动转化为左右移动的证明思路，并指出其背后的群论本质：旋转是状态空间上的一个自同构，而”旋转变换→执行操作→旋转变换回来”的模式正是群作用中的共轭思想。全文给出严格引理与完整构造，展示对称性如何让证明变得更整体、更优雅。
设 $n$ 为正奇数。在一个 $n\times n$ 的网格中，放置有数字 $1,2,\dots,n^2-1$ 以及一个空格（记作 $0$）。每一步可以将空格与其上、下、左、右相邻的数字交换位置。给定两个局面（状态）$A$ 和 $B$，问是否可以通过一系列合法移动将 $A$ 变为 $B$。
已知事实（必要性）：将局面按行优先展开成一个长度为 $n^2$ 的序列（舍去 $0$），其逆序对数量的奇偶性在任何合法移动下保持不变。
因此，若 $A$ 与 $B$ 的逆序对奇偶性不同，则它们一定不可达。
目标（充分性）：若 $A$ 与 $B$ 的逆序对奇偶性相同，证明它们一定可以相互到达。
传统证明中，需要围绕”如何在不破坏已归位数字的前提下上下移动一个数字”进行复杂的行走构造。本证明的核心是视角转换：
这一想法本质上等同于：旋转是奇数码问题状态空间的一个自同构，它保持移动关系与逆序对性质。而“旋转—执行操作—逆旋转”的步骤，正是群作用理论里共轭的典型用法。
记状态空间为 $\mathcal{S}$，包含所有将 $0,1,\dots,n^2-1$ 填入 $n\times n$ 网格的排列。定义：
引理 0（必要性）：若 $A\sim B$，则 $\operatorname{inv}(A)\equiv\operatorname{inv}(B)\pmod{2}$。
此即已知结果，不赘证。
引理 1（自由左右移动）
设当前状态中，已有前 $m$ 个数字（按目标状态 $T$ 的顺序）放在了它们的正确位置，且这些位置构成棋盘左上角的一个矩形区域（即已填满若干整行加上下一行的前若干格）。对于任意数字 $k$ （$k$ 尚未归位），只需利用待处理区域（剩余格子），就可以将该数字左右移动到任意目标列，而不改变任何已归位数字的位置。
证明
将空格移动到数字 $k$ 的同行、相邻列，然后通过与空格交换来实现左右移动。由于已归位区域在左上角且连续，空格在剩余区域内总是有足够的自由度绕到 $k$ 的左侧或右侧，且所有路径不会穿过已完成区域。具体构造可参考标准八数码问题中的“空格绕行”方法，这里不再画格子说明。
关键点：该引理只要求“剩余区域连通且不受已完成数字阻挡”，而这对于左上角矩形区域是自然成立的。
定义映射 $R:\mathcal{S}\to\mathcal{S}$ 为将整个棋盘顺时针旋转 $90^\circ$（格子内容跟随旋转）。也就是说，原位置 $(i,j)$ 的数字移动到新位置 $(j,n+1-i)$。
引理 2（旋转不改变可达性与逆序对）
对于奇数 $n$，旋转 $R$ 满足：
证明
(1) 因为 $R$ 是网格图的一个自同构：它将相邻关系映为相邻关系，且把空格映射到空格的位置。因此，$A$ 中一步移动对应 $R(A)$ 中同样的一步移动，只是方向旋转了 $90^\circ$。递推可得可达性等价。
(2) 将 $n\times n$ 的格子按行优先编号。旋转 $R$ 诱导了格子集合上的一个置换 $\sigma$。当 $n$ 为奇数时，中心一格不动，其余 $n^2-1$ 个格子均落在长度为 $4$ 的循环中，且 $4$-循环的个数为 $\frac{n^2-1}{4}$，由于 $n$ 为奇数，该数为整数且为偶数。每个 $4$-循环是奇置换，偶数个奇置换的乘积为偶置换，故 $\sigma$ 是偶置换。
由于 $A$ 按行优先展开成的序列可通过将目标序列按 $\sigma^{-1}$ 重排得到，而偶置换不改变排列的奇偶性，因此展开序列（含 $0$）的奇偶性在旋转前后不变。去掉 $0$ 后，$0$ 在序列中位置的改变等价于对剩余 $n^2-1$ 个元素施加某个置换，该置换的奇偶性与 $\sigma$ 的奇偶性相关，但恰好与 $0$ 位置变化带来的影响抵消，最终 $\operatorname{inv}(R(A))$ 与 $\operatorname{inv}(A)$ 奇偶性相同。具体推导亦可见经典置换群教材中的标准结论。
注：这是整个证明中唯一需要计算置换奇偶性的地方，且仅在处理逆序对不变量时才用到。
使用旋转时，我们关心的是：当我们在“旋转后的视角”下应用引理 1 时，已完成区域的形状是否还能保证剩余区域连通。
引理 3（旋转后的区域适配）
假设在原视角下，已归位的前 $m$ 个数字占据左上角的标准矩形区域（即整行整列的阶梯形）。将当前状态 $C$ 与目标状态 $T$ 同时顺时针旋转 $90^\circ$，得到 $R(C)$ 与 $R(T)$。
在 $R(T)$ 中，前 $m$ 个数字（相同的数字集合）占据的位置仍然是连通的，且它们的补集（剩余自由格子）构成一个连通的、没有“孤岛”的区域，使得引理 1 的前提仍然成立。
证明
原左上角的矩形区域旋转后变成右上角或底部的一个矩形区域，具体形状因矩形是否填满整行而略有不同，但无论如何，已归位数字总是形成一个“角落区域”，剩余格子是一个连通的矩形/ L 形区域。因为 $n$ 为奇数且是整行整列归位，补集始终连通。例如，前 $n$ 个数字填满第一行，旋转后变成最右列，剩余区域仍为 $(n-1)\times n$ 的连通块，空格完全可以在其中活动。
这保证了：在新视角下，我们依然可以安全地调用引理 1 来左右移动某个数字，而不会破坏任何已归位数字。
定理（充分性）
若两个状态 $A$ 与 $B$ 满足 $\operatorname{inv}(A)\equiv\operatorname{inv}(B)\pmod{2}$，则 $A$ 可达 $B$。
证明
我们证明任意状态 $A$ 都可以到达某个“标准状态”，而标准状态只有两个（逆序对奇偶性各对应一个），因此奇偶性相同的状态互达。
构造过程：从状态 $A$ 开始，按行优先顺序依次将数字 $1,2,\dots,n^2-3$ 归位（最后留下右下角 $2\times2$ 区域暂不处理）。
假设前 $k-1$ 个数字已经放在正确位置（即与目标状态 $T$ 中位置一致）。现在要放置数字 $k$。
重复此步骤，直到只剩下右下角 $2\times2$ 区域（三个数字加一个空格）。
最后的 $2\times2$ 区域：
此时棋盘上只剩三个数字和空格未归位，总状态数只有 $4! = 24$ 种，但考虑到空格只能在 $2\times2$ 内移动，实际上可能的状态只有 $4$ 种（空格固定一角时数字的 $3!$ 排列受限于平面移动）。更直接地，可以证明这 $2\times2$ 区域的所有合法移动不改变整个棋盘逆序对的奇偶性，并且恰好有 两类 排列状态，分别对应逆序对奇偶性的奇和偶。由于我们在整个过程始终维持逆序对奇偶性不变（由引理 0 和引理 2 保证），最终的 $2\times2$ 状态必属于与初始 $A$ 相同奇偶性的那一类。若与目标状态的逆序对奇偶性相同，最后三个数字的排列必定是目标状态中的顺序；若与目标状态的逆序对奇偶性不同，则是交换了某两个数字的状态（即不可达的另一个标准态）。
因此，任意奇偶性相同的状态都可以用上述过程到达同一个标准状态（例如所有数字归位的目标状态 $T$），从而它们彼此可达。$\square$
回过头看，“旋转–执行操作–逆旋转”这个三步走的做法，在群论中有个名字：共轭。
把状态空间 $\mathcal{S}$ 视为集合，合法移动序列构成的群记为 $G$（实际是生成这些移动的变换群，但不必显式写出）。旋转 $R$ 是 $\mathcal{S}$ 上的一个双射，且它保持移动关系，即 $R(g(x)) = g’(R(x))$ 对某个 $g’\in G$ 成立，相当于说 $R$ 正规化 $G$。
当我们想要实现一个垂直移动操作 $f$（在原始问题上很麻烦）时，我们不直接构造 $f$，而是：
所得的操作 $R^{-1}\circ h \circ R$ 就是原始坐标系下的垂直移动。这就是群作用理论中利用对称性传递操作的核心技巧。
同时，引理 2 中“旋转不改变逆序对”本质上利用了旋转置换是偶置换这一群论事实，这与“旋转是状态空间的一个对称性”是相容的。整个证明可以看作：利用旋转群 $\langle R\rangle$ 对状态空间的作用，将困难的“上下移动”约化为已经解决的“左右移动”，这正是群作用下轨道分析的一个朴素实例。
对于只自学了 40 多页群论就直觉到“一看见对称就想到群”的笔者来说，这个证明可以说是一次与抽象代数的神交——它在没有显式写出群、轨道、稳定子等术语的情况下，已经运用了共轭与群作用的核心思维。
奇数码问题的充分性证明之所以常被略去，是因为复杂的分情形构造容易淹没问题的本质。而当我们抬起视角，利用棋盘自身的旋转对称性，证明就变得有节奏、有结构，甚至透露出群论的影子。这个证明不仅让充分性“显然”，更是一次美妙的思想实验：原来对称性不只是现象，它可以成为证明的工具。
对于竞赛选手，掌握这种“旋转视角”的技巧也可能在其他网格问题中发挥作用；对于数学爱好者，它则是一扇窥见群作用思想的窗——不需要把群论学完，就能先呼吸到它的空气。
]]>给你一个无向图，有 \(n\) 个顶点和 \(m\) 条边。现在需要给图中的每个顶点染色，要求相邻的顶点不能染相同颜色。请问最少需要多少种颜色才能完成染色？
这就是经典的图着色问题（Graph Coloring Problem），属于 NP-完全问题，当图规模较小时可以用回溯法（DFS + 剪枝）求解。
我们采用回溯法（DFS），逐一为每个顶点选择合法颜色，并利用当前已知的最优解进行剪枝。
由于有 \(n\) 个顶点，最坏情况下每个顶点一种颜色，因此答案一定在 \(1 \sim n\) 之间。我们可以从小到大猜测所需颜色数，尝试用不超过该数量的颜色给图染色。如果染色成功，说明当前猜测数可行；否则需要增加颜色数。
定义 dfs(u, cur_max)：当前正在给第 \(u\) 个顶点染色，猜测的最多可用颜色数为 cur_max。
cur_max >= ans（当前已找到的最优解），则直接返回，不再继续搜索。ans = cur_max 并返回。0 到 cur_max - 1 号颜色，如果颜色 \(i\) 与已染色的邻接顶点不冲突，则将顶点 \(u\) 染成 \(i\)，然后递归 dfs(u+1, cur_max)，最后回溯 color[u] = -1。cur_max（新颜色），递归 dfs(u+1, cur_max+1)，然后回溯 color[u] = -1。color[u] 重置为 不可能的值。若颜色编号从 0 开始，则重置为 -1；若从 1 开始，则重置为 0。问题描述
\(n\) 个人参加某项特殊考试。为了公平，要求任何两个认识的人不能分在同一个考场。求至少需要分几个考场才能满足条件。
输入格式
第一行一个整数 \(n\)（\(1 \le n \le 100\)），表示参加考试的人数。 第二行一个整数 \(m\)，表示接下来有 \(m\) 行数据。 接下来 \(m\) 行，每行两个整数 \(a, b\)（\(1 \le a, b \le n\)），表示第 \(a\) 个人与第 \(b\) 个人认识。
输出格式
输出一行一个整数，表示最少分几个考场。
运行限制
- 最大运行时间：1s
- 最大运行内存：256MB
样例输入
样例输出
这道题正是图着色问题的经典应用：
因此，上述回溯算法完全适用于此题。唯一需要注意的是，题目中 \(n\) 的最大值可达 100，如果直接套用暴力回溯会超时。实际竞赛中通常采用贪心策略或更优的剪枝方法来解决较大规模的数据。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
#include <iostream>
#include <vector>
#include <functional>
using namespace std;
int main()
{
int n, m;
cin >> n >> m;
vector<vector<bool>> adj(n, vector<bool>(n, false));
for (int i = 0; i < m; ++i)
{
int a, b;
cin >> a >> b;
adj[a - 1][b - 1] = true;
adj[b - 1][a - 1] = true;
}
vector<int> color(n, -1);
int ans = n;
auto is_safe = [&](int u, int c) -> bool
{
for (int i = 0; i < n; ++i)
{
if (adj[u][i] && color[i] == c)
return false;
}
return true;
};
function<void(int, int)> dfs = [&](int u, int cur_max)
{
if (cur_max >= ans)
return;
if (u >= n)
{
ans = cur_max;
return;
}
for (int i = 0; i < cur_max; ++i)
{
if (is_safe(u, i))
{
color[u] = i;
dfs(u + 1, cur_max);
color[u] = -1;
}
}
color[u] = cur_max;
dfs(u + 1, cur_max + 1);
color[u] = -1;
};
dfs(0, 0);
cout << ans << '\n';
return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
#include <bits/stdc++.h>
using namespace std;
int main()
{
int n, m;
cin >> n >> m;
vector<vector<bool>> adj(n, vector<bool>(n, 0));
for (int i = 0; i < m; ++i)
{
int a, b;
cin >> a >> b;
adj[a - 1][b - 1] = true;
adj[b - 1][a - 1] = true;
}
vector<int> color(n, -1);
int ans = n;
auto is_safe = [&](int u, int c) -> bool
{
for (int i = 0; i < n; ++i)
{
if (adj[u][i] && color[i] == c)
return false;
}
return true;
};
function<void(int, int)> dfs = [&](int u, int cur_max)
{
if (cur_max >= ans)
return;
if (u >= n)
{
ans = cur_max;
return;
}
// 尝试使用已有的颜色（0 ~ cur_max-1）
for (int i = 0; i < cur_max; ++i)
{
if (is_safe(u, i))
{
color[u] = i;
dfs(u + 1, cur_max);
color[u] = -1; // 回溯
}
}
// 尝试使用新颜色 cur_max
color[u] = cur_max;
dfs(u + 1, cur_max + 1);
color[u] = -1; // 回溯
};
dfs(0, 0);
cout << ans << '\n';
return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
#include <iostream>
#include <vector>
#include <functional>
using namespace std;
int main()
{
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
vector<vector<bool>> adj(n + 1, vector<bool>(n + 1, false));
vector<int> color(n + 1);
for (int i = 0; i < m; ++i)
{
int u, v;
cin >> u >> v;
adj[u][v] = adj[v][u] = true;
}
function<bool(int, int)> is_safe;
is_safe = [&](int u, int c) -> bool
{
for (int i = 1; i <= n; ++i)
{
if (adj[u][i] && color[i] == c)
return false;
}
return true;
};
int ans = n;
function<void(int, int)> dfs;
dfs = [&](int u, int cur_max) -> void
{
if (cur_max >= ans)
return;
if (u > n)
{
ans = cur_max;
return;
}
// 尝试使用已有的颜色（1 ~ cur_max）
for (int i = 1; i <= cur_max; ++i)
{
if (is_safe(u, i))
{
color[u] = i;
dfs(u + 1, cur_max);
color[u] = 0; // 回溯（0 表示未染色）
}
}
// 尝试使用新颜色 cur_max + 1
color[u] = cur_max + 1;
dfs(u + 1, cur_max + 1);
color[u] = 0; // 回溯
};
dfs(1, 0);
cout << ans << '\n';
return 0;
}
ans 进行剪枝，大幅减少搜索空间。