Cpp on Aminiam's Blog

C CPP 解包

Fri, 09 Oct 2026 14:49:53 +0800

`C`可變參數解包

示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


#include <stdio.h>
#include <stdarg.h>

int sum(int n, ...)
{
 va_list ap;
 va_start(ap, n);

 int ans = 0;

 for (int i = 0; i < n; ++i)
 ans += va_arg(ap, int);

 va_end(ap);
 return ans;
}

int main()
{
 printf("%d\n", sum(4, 1, 3, 5, 7));
 return 0;
}

1

16

C++ 可變參數模板與遞歸解包

方式一：遞歸解包

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


#include <iostream>

using namespace std;

template<typename T>
T maxn(T a) { return a; }

template<typename T, typename... Args>
T maxn(T a, Args... rest)
{
 T b = maxn(rest...);
 return a > b ? a : b;
}

int main()
{
 cout << maxn<double>(1.1, 2.2, 3.3) << endl;
 return 0;
}

方法二：摺疊表達式

類型	寫法	展開結果
一元左摺疊	`(... + args)`	`((a + b) + c)`
一元右摺疊	`(args + ...)`	`(a + (b + c))`
二元左摺疊	`(0 + ... + args)`	`(((0 + a) + b) + c)`
二元右摺疊	`(args + ... + 0)`	`(a + (b + (c + 0)))`

示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


#include <iostream>

using namespace std;

template<typename T, typename... Args>
T maxn(T a, Args... args)
{
 ((a = a > args ? a : args), ...);
 return a;
}

int main()
{
 cout << maxn<double>(1.1, 2.2, 3.3, 4.4) << endl;
 return 0;
}

完美轉發

1
2
3
4
5
6
7


#include <utility>

template<typename T>
void wrapper(T&& x)
{
 process(std::forward<T>(x));
}

1
2


template<typename... Args>
void print(Args&&... args) { std::cout << ... <<< std::forward<Args>(args) }

Notes for C

Thu, 17 Sep 2026 13:55:05 +0800

C

register
volatile：指定變量可能被外部修改，每次都應重新讀取，不應相信緩存
1.5: double, 1.5f: float, 1.5L: long double
fabs(x - y) < \varepsilon $\leftrightarrow$ $|x - y| <\varepsilon$; fabs(x - y) < fabs(x * \varepsilon) $\leftrightarrow$ $|x-y|<|x|\varepsilon$

轉義字符：

字符	含義
`\b`	backspace
`\r`	回車，光標移動到行首
`\t`	tab
`\v`	vertical tab
`\f`	走紙換頁
`\\`
`\"`
`\'`
`\ddd`	三位八進制
`\xdd`	兩位十六進制

格式輸入輸出
逗號表達式：從左向右依次計算，最後一個表達式的值作爲表達式運算的結果
只有一元、三元、賦值運算的結合性爲從右向左
隱式轉換規則：short, char -> int -> unsigned int -> long -> unsigned long -> float -> double -> long double
字符串拼接：
- 方式一：'\'自動拼接
- 方式二：“A ““B” = “A B”：相連的字符串常量自動拼接
scanf("%d", s)會在空格中止，gets(s)會在行尾中止

<cstring>:

function	def
strlen()
strcpy(s1, s2)	s2複製到s1
strncpy(s1, s2, n)	將s2中前n個字符複製到s1
strcat(s1, s2)	將s2追加到s1中
strcmp(s1, s2)	返回字典序`s1 > s2 ? :`
strlwr(s)	覆寫s爲lowercase
strupr(s)	覆寫s爲uppercase
puts(s)	`printf("%s", s)`
gets()

`printf` `scanf` Format Quick Lookup

Wed, 02 Sep 2026 13:59:38 +0800

一、格式说明符

格式符	printf 参数类型	scanf 参数类型	说明
`%d`	`int`	`int*`	十进制有符号整数
`%u`	`unsigned int`	`unsigned int*`	十进制无符号整数
`%o`	`unsigned int`	`unsigned int*`	八进制
`%x`	`unsigned int`	`unsigned int*`	十六进制（小写）
`%X`	`unsigned int`	`unsigned int*`	十六进制（大写）
`%f`	`double`	`float*`	浮点数（printf 用 `%f`/`%lf` 均可，scanf 必须 `%f` 给 float，`%lf` 给 double）
`%e`	`double`	`float*`	科学计数法（小写 e）
`%g`	`double`	`float*`	自动选 `%f` 或 `%e`（较短）
`%c`	`char`	`char*`	单个字符
`%s`	`const char*`	`char[]`	字符串（遇空白停止）
`%p`	`const void*`	`void**`	指针地址（十六进制）
`%n`	`int*`	`int*`	写入已输出/读取的字符数
`%%`	-	-	输出字面量 `%`

二、长度修饰符

修饰符	适用类型示例	格式
`hh`	`signed char` / `unsigned char`	`%hhd`, `%hhu`
`h`	`short` / `unsigned short`	`%hd`, `%hu`
`l`	`long` / `unsigned long`	`%ld`, `%lu`
`ll`	`long long` / `unsigned long long`	`%lld`, `%llu`
`L`	`long double`	`%Lf`, `%Le`
`z`	`size_t`	`%zd`
`t`	`ptrdiff_t`	`%td`

三、`printf`常用标志

标志	作用	示例（`%`后加标志）
`-`	左对齐（默认右对齐）	`%-10d`
`+`	强制显示正负号	`%+d`
空格	正数前加空格	`% d`
`#`	八进制前加`0`，十六进制加`0x`/`0X`，浮点数强制小数点	`%#o`, `%#x`, `%#f`
`0`	用 `0` 填充宽度（而非空格）	`%08d`

四、宽度与精度

格式	含义	示例
`%最小宽度d`	输出至少占 n 位，不足补空格	`%5d`
`%.精度f`	小数位数（浮点）/ 最大字符数（字符串）/ 最少数字位数（整数）	`%.2f`, `%.5s`
`%.f`	宽度和精度由参数提供	`printf("%.f", w, p, val);`

五、scanf 特殊用法

用法	说明	示例
`*`	抑制赋值（跳过）	`scanf("%*d %d", &n);`
`[集合]`	只读指定字符集	`%[a-z]`（读小写字母）
`[^]`	读直到遇到某字符	`%[^,]`（读逗号前）

CPP __Builtin_

Wed, 02 Sep 2026 13:52:32 +0800

CPP Builtin

1. 位运算与计数

函数	功能描述	示例	注意
`__builtin_popcount(x)`	返回 `x` 的二进制中 1 的个数	`__builtin_popcount(15)` → `4`	有 `popcountl`、`popcountll` 版本
`__builtin_clz(x)`	返回从最高位开始的前导零个数	`__builtin_clz(1)`（32位）→ `31`	传入 `0` 是未定义行为；有 `clzl`、`clzll`
`__builtin_ctz(x)`	返回从最低位开始的尾随零个数	`__builtin_ctz(8)` → `3`	传入 `0` 是未定义行为；有 `ctzl`、`ctzll`
`__builtin_ffs(x)`	返回最低位 1 的位置（从 1 开始）	`__builtin_ffs(8)` → `4`	`x=0` 时返回 `0`；有 `ffsl`、`ffsll`
`__builtin_parity(x)`	返回 1 的个数的奇偶性（奇数个1→1）	`__builtin_parity(15)` → `0`	有 `parityl`、`parityll`

2. 算术运算与安全

函数	功能描述	示例	注意
`__builtin_add_overflow(a, b, &res)`	安全加法，检测是否溢出	溢出返回 `true`，否则存入 `res` 并返回 `false`	支持 `sub`（减法）和 `mul`（乘法）
`__builtin_abs(x)` 等	计算整数或浮点数的绝对值	`__builtin_abs(-10)` → `10`	有 `labs`、`llabs`、`fabs` 等版本

3. 优化与调试

函数	功能描述	示例	注意
`__builtin_expect(exp, c)`	提供分支预测信息，优化代码布局	常与 `if` 结合，如 `if (__builtin_expect(ptr == nullptr, 0))`	错误使用可能降低性能
`__builtin_trap()`	强制执行陷阱指令，程序异常终止	用于不应执行到的代码路径	–
`__builtin_unreachable()`	告诉编译器某路径永远不会执行，辅助优化	常用于 `switch` 的 `default` 分支（当所有情况已覆盖）	–

Sudoku Solver: Bitmask & MRV

Wed, 02 Sep 2026 13:28:15 +0800

Sudoku Solver

LeetCode 原题地址：37. Sudoku Solver

狀態壓縮：Bitmask

使用$9$位的二進制整數分別表示$1\to9$。

標記佔用：rows[r] |= (1 << (d - 1))

撤銷佔用：rows[r] ^= (1 << (d - 1))

計算候選數：used = rows[r] | cols[c] | boxes[b]，那麼可用數字：available = (~used) & 0b111111111（取反後保留低$9$位）

MRV(Minimum Remaining Values)：最小剩餘值啓發式

先填最難的。

比如：有一個空格，行裏缺{1, 2}，列裏缺{1, 2, 3}，宮裏缺{1}（唯一解），就優先填它。

這是在“最受限”的位置做決策。如果唯一解的地方都填錯了，說明之前的選擇有無，可以儘早回溯（Fail-First 原則）。反之如果先去填有$9$可能的空格，會浪費大量算力。

實現方法：在每一層遞歸開始時，掃描所有剩餘空格，找出available裏$1$個數最少的，交換到當前處理位置。

遍歷方法：位運算提取候選（Lowbit 技巧）

取最低位的1：bit = available & -available
Count Trailing Zeros：d = __builtin_ctz(bit)

算法流程：DFS 回溯

初始化：掃描整個棋盤，將已填數字更新到rows，cols，boxes中，同時記錄所有空格座標。
遞歸入口（backtrack(idx)）
- 終止條件：如果idx等於空格總數，說明填完了，返回true。
- MRV 選點：從idx到末尾遍歷所有空格，計算每個空格的available掩碼，統計1的個數，選出最小的那個，並交換到empties[idx]位置。
- 嘗試填入：獲取當前空格的available掩碼，利用lowbit去除每一個候選數字。
- 放置並遞歸：修改棋盤，更新rows/cols/boxes掩碼，調用backtrack(idx + 1)。
- 回溯撤銷：如果遞歸返回false，說明這條路走不通，撤銷掩碼，將棋盤改回'.'，嘗試下一個候選。
結果：一旦找到解，遞歸棧層層返回true，完成求解。

實現

emplace_back(r, c)就地構造，push_back(make_pair(r, c))或者push_back({r, c})會產生臨時變量，儘管對於一般的情況會被-O2優化。
function<bool(int)>通用函數包裝器，意爲任意一個接受int參數，並返回bool值的可調用對象（函數、仿函數、Lambda）。
[&]按引用捕獲，[=]按值捕獲。
std::function有微小性能損耗，大約$5%\to10%$，因爲底層使用了類型擦除，調用時會多一次間接尋址。追求極致可使用auto + Y-Combinator（不動點組合子）來替代以消除開銷。
idx表示当前处理到第idx个空格。

 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


class solution
{
 public:
 void solveSudoku(vector<vector<char>>& board)
 {
 int rows[9] = {0}, cols[9] = {0}, boxes[9] = {0};
 vector<pair<int, int>> empties;

 for (int r = 0; r < 9; ++r)
 for (int c = 0; c < 9; ++c)
 if (board[r][c] == '.')
 empties.emplace_back(r, c);
 else
 {
 int d = board[r][c] - '1';
 int mask = 1 << d;
 int b = (r / 3) * 3 + (c / 3);
 rows[r] |= mask;
 cols[c] |= mask;
 boxes[b] |= mask;
 }
 
 function<bool(int)> backtrack = [&](int idx) -> bool
 {
 if (idx == empties.size()) return true;

 int bestIdx = idx;
 int minCandidates = 10;
 for (int i = idx; i < empties.size(); ++i)
 {
 int r = empties[i].first, c = empties[i].second;
 int b = (r / 3) * 3 + (c / 3);
 int used = rows[r] | cols[c] | boxes[b];
 int available = (~used) & 0b111111111;
 int cnt = __builtin_popcount(available);
 if (cnt < minCandidates)
 {
 minCandidates = cnt;
 bestIdx = i;
 if (cnt == 1) break;
 }
 }
 if (bestIdx != idx) swap(empties[idx], empties[bestIdx]);
 int r = empties[idx].first, c = empties[idx].second;
 int b = (r / 3) * 3 + (c / 3);
 int used = rows[r] | cols[c] | boxes[b];
 int available = (~used) & 0b111111111;

 while (available)
 {
 int bit = available & -available;
 int d = __builtin_ctz(bit);
 available ^= bit;
 board[r][c] = char('1' + d);
 rows[r] |= bit;
 cols[c] |= bit;
 boxes[b] |= bit;

 if (backtrack(idx + 1)) return true;

 board[r][c] = '.';
 rows[r] ^= bit;
 cols[c] ^= bit;
 boxes[b] ^= bit;
 }
 return false;
 };
 backtrack(0);
 }
};

不動點組合子

經典錯誤寫法：

1
2
3
4


auto backtrack = [&](int idx) -> bool
{
 if (backtrack(idx + 1)) return true;
};

錯誤因爲backtrack還沒有聲明完，不能在內部調用。

普通解決方案，用std::function，但是存在性能損耗。

解決方案核心思想：把自己作爲參數傳遞進去：

1
2
3
4
5


auto backtrack = [](auto&& self, int idx) -> bool
{
 if (self(self, idx + 1)) return true;
 return false;
};

左值、右值和萬能引用`auto&&`

定義

任何一個cpp表達式在編譯器視角都有一下兩個獨立屬性：

擁有身份（Has Identity）：這個表達式是否代表一塊具體的內存地址？能否用&取到它的地址？
可被移動（Is Movable）：這個表達式的值是否允許被“竊取”（轉移資源），因爲它馬上就要被銷燬了？

基於以上兩個不二屬性，表達式分爲三大類：

左值：Lvalue，有身份
純右值：Prvalue，沒有（臨時寄存器）
亡值：Xvalue，有（即將被銷燬的對象）
右值：Rvalue，純右值或者亡值（要麼沒有地址，要麼瀕臨死亡）

1
2
3
4
5
6
7


int a = 10;
int b = a; // a 是左值，但是出現在等號右邊
&a; // 合法，取左值的地址
&10; // 非法，取右值的地址
// 但可以將右值轉化爲左值（亡值）：
int&& c = 10; // 將亡值綁定到右值引用上
&c; // 現在 c 有地址，它是亡值，屬於右值但是可取地址

分析

1
2


auto backtrack = [](auto&& self, int idx) { ... };
backtrack(backtrack, 0);

對於這裏的backtrack：

這是一個具名變量，編譯器爲它在棧上分配了內存
它擁有確定的內存地址，可以&backtrack
它不會在函數調用結束時銷燬（它處於外層作用域）

因此backtrack是一個左值，傳給auto&&後，推導爲左值引用Type&

對於0：

它不佔用靜態或棧上的內存，直接作爲立即數編碼在 CPU 的彙編指令集
它沒有任何內存地址
它是一個臨時值，函數調用完就丟棄

因此0是一個純右值，傳給int indx時發生拷貝

`T&&`

情況一：type是具體類型（無推導），這是一個右值引用，會拒絕左值。

情況二：type是推導佔位符（auto或template T），這是轉發引用，如果傳遞左值，摺疊爲T&，傳入右值，摺疊爲T&&。

std::move

std::move(a)是類型強轉，對於基礎類型：

1
2


int a = 1;
int b = std::move(a);

執行第二句時，編譯器查找int的構造函數，發現int沒有移動構造函數，於是移動退化爲拷貝，結果是a和b分別指向兩塊內存都儲存了1

對於資源類型：

1
2


vector<int> a = {1, 2, 3};
vector<int> b = std::move(a);

執行std::move(a)時a並未改變，執行vector<int> b = std::move(a);時，vector的移動構造函數完成三件事：

將b指向a本來指向的地址，並將a設置爲nullptr
將b的大小設置爲a的大小，並將a的大小設置爲0
將b的容量指向a的容量，並將a的容量歸零

構造函數初始化列表

節省先构造一个默认空對象再赋值數據的冗餘操作，const成員、引用成員、無默認構造對象必須使用函數初始化列表

1
2
3
4
5
6
7
8


class Student
{
private:
 string name;
 int age;
public:
 Student(string n, int a) : name(n), age(a) {}
};

多邊形重心

Tue, 25 Aug 2026 23:30:24 +0800

原題

AtCoder 原題：F - Centroid of a Slice

多边形重心坐标

對有$N$個頂點的平面多邊形的每個頂點有$(x_i,y_i)$有：

$$ G_x = \frac{\sum_i{(x_i+x_{i+1})S_i}}{3\sum_i{S_i}} \newline G_y = \frac{\sum_i{(y_i+y_{i+1})S_i}}{3\sum_i{S_i}} $$

其中：

$$ S_i = \frac{1}{2}(x_iy_{i+1}-x_{i+1}y_i) \newline x_{N+1} = x_1 \newline y_{N+1} = y_1 $$

注意事項

使用前綴和時，記得閉合最後一條邊。

AC代碼

 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


#include <cstdio>

const int SIZE = (1e6 + 10);
typedef long double ld;

int main()
{
 //read
 int N, Q; scanf("%d%d", &N, &Q);
 int x[SIZE] = {0}, y[SIZE] = {0};
 ld ax[SIZE] = {0}, ay[SIZE] = {0}, b[SIZE] = {0};
 for (int i = 1; i <= N; i++)
 scanf("%d%d", &x[i], &y[i]);
 x[N + 1] = x[1]; y[N + 1] = y[1];
 for (int i = 1; i <= N; i++)
 {
 ax[i] = ax[i - 1] + ((ld)x[i] + (ld)x[i + 1]) * ((ld)x[i] * (ld)y[i + 1] - (ld)x[i + 1] * (ld)y[i]);
 ay[i] = ay[i - 1] + ((ld)y[i] + (ld)y[i + 1]) * ((ld)x[i] * (ld)y[i + 1] - (ld)x[i + 1] * (ld)y[i]);
 b[i] = b[i - 1] + (ld)x[i] * (ld)y[i + 1] - (ld)x[i + 1] * (ld)y[i];
 }
 //output
 for (int i = 0; i < Q; i++)
 {
 int u, v; scanf("%d%d", &u, &v);
 ld ans_x, ans_y, sb, sax, say;
 if (u < v)
 {
 sb = b[v - 1] - b[u - 1];
 sax = ax[v - 1] - ax[u - 1];
 say = ay[v - 1] - ay[u - 1];
 }
 else
 {
 sb = b[N] - b[u - 1] + b[v - 1];
 sax = ax[N] - ax[u - 1] + ax[v - 1];
 say = ay[N] - ay[u - 1] + ay[v - 1];
 }
 //close
 ld c = (ld)x[v] * (ld)y[u] - (ld)x[u] * (ld)y[v];
 sb += c;
 sax += ((ld)x[v] + (ld)x[u]) * c;
 say += ((ld)y[v] + (ld)y[u]) * c;
 ans_x = sax / sb / 3.0L;
 ans_y = say / sb / 3.0L;
 printf("%.12Lf %.12Lf\n", ans_x, ans_y);
 }
 return 0;
}

tree板子

Sat, 22 Aug 2026 16:18:53 +0800

方案一：vector 鄰接表

使用vector<int> n;，n[i]儲存了第$i$個節點的所有鄰居。

`add(a, b)` (vector)

1
2


a.push_back(b);
b.push_back(a);

DFS (vector)

遞歸實現，首先定義bool st[SIZE] = {false};來記錄節點是否被訪問過。

1
2
3
4
5
6
7
8


void dfs(head)
{
 st[head] = true; //標記當前節點
 run(head); //執行操作
 for (auto v : n[head])
 if (!st[v])
 dfs(v);
}

BFS (vector)

使用隊列queue<int> q;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


st[head] = true; //先記錄head已經被訪問
q.push(head); //將head插入隊尾
while (!q.empty()) //開始循環
{
 int f = q.front();
 q.pop();
 run(f);
 for (auto v : n[f]) 
 if (!st[v])
 {
 st[v] = true;
 q.push(v);
 }
}

方案二：鏈式前向星

定義：

1
2
3
4


int h[N];
int e[2 * N];
int ne[2 * N];
int id = 0;

`add(a, b)` (static)

1
2
3
4
5
6
7
8


id++; //分配內存
e[id] = b; //儲存值
ne[id] = h[a]; //頭插
h[a] = id; //頭插
id++
e[id] = a;
ne[id] = h[b];
h[b] = id;

DFS (static)

遞歸實現：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


void dfs(head)
{
 st[head] = true;
 run(head);
 for (int i = n[head]; i; i = ne[i])
 {
 int v = e[i];
 if (!st[v])
 {
 st[v] = true;
 dfs(v);
 }
 }
}

BFS (static)