Docs test (written by ChatGPT)

Author: a1fredbao

documents/alfred/algorithm/pair-counting.md

@@ -0,0 +1,30 @@
+---
+title: Pair Counting Utilities
+documentation_of: ./src/alfred/algorithm/pair-counting.hpp
+---
+
+## Description
+
+This file implements a generic pair counting utility, suitable for efficiently counting the number of pairs that satisfy a given comparison function, commonly used for problems like inversion counting.
+
+## Usage Example
+
+```cpp
+#include "pair-counting.hpp"
+std::vector<int> a = {3, 1, 2};
+size_t inv = count_pair(a, std::greater<int>()); // Count inversions
+```
+
+## Main Features
+- Supports custom comparison functions for pair counting
+- Uses merge sort idea, time complexity $O(n \log n)$
+- Does not modify the original data (pass by value)
+
+## Important Functions and Time Complexity
+
+| Function     | Description                 | Time Complexity |
+| ------------ | --------------------------- | --------------- |
+| `count_pair` | Count pairs satisfying comp | $O(n \log n)$   |
+
+## Notes
+- Suitable for counting pairs that satisfy any binary relation.

documents/alfred/algorithm/utils.md

@@ -0,0 +1,35 @@
+---
+title: Algorithm Utilities
+documentation_of: ./src/alfred/algorithm/utils.hpp
+---
+
+## Description
+
+This file provides a set of common algorithm utility functions, including max/min value updates and vector output, to simplify code writing.
+
+## Usage Example
+
+```cpp
+#include "utils.hpp"
+int x = 1;
+chkmax(x, 5); // x = 5
+chkmin(x, {2, 3, 4}); // x = 2
+std::vector<int> v = {1, 2, 3};
+write_vec(v);
+```
+
+## Main Features
+- Batch max/min update functions
+- Supports initializer_list
+- Vector output functions, supports single/multi-line
+
+## Important Functions and Time Complexity
+
+| Function    | Description      | Time Complexity |
+| ----------- | ---------------- | --------------- |
+| `chkmax`    | Max value update | $O(n)$          |
+| `chkmin`    | Min value update | $O(n)$          |
+| `write_vec` | Output vector    | $O(n)$          |
+
+## Notes
+- Useful for common helper operations in contests and daily development.

documents/alfred/config/fast-io.md

@@ -0,0 +1,36 @@
+---
+title: Fast Input/Output Utilities
+documentation_of: ./src/alfred/config/fast-io.hpp
+---
+
+## Description
+
+This file provides fast input and output utilities for C++, including a custom FastIO class for buffered reading and writing, as well as template functions for fast reading and writing of integers and modular integers.
+
+## Usage Example
+
+```cpp
+#include "fast-io.hpp"
+int x;
+fast_read(x);
+write(x);
+writeln(x);
+```
+
+## Main Features
+- Fast buffered input and output
+- Supports reading and writing of integers and modular integer types
+- Allows resizing of the input buffer
+- Variadic template for reading multiple variables
+
+## Important Functions and Time Complexity
+
+| Function     | Description                    | Time Complexity |
+| ------------ | ------------------------------ | --------------- |
+| `fast_read`  | Fast read integer(s)           | $O(1)$ per int  |
+| `write`      | Fast write integer/modular int | $O(\log n)$     |
+| `writeln`    | Fast write with newline        | $O(\log n)$     |
+| `reset_size` | Resize the input buffer        | $O(1)$          |
+
+## Notes
+- Useful for competitive programming and scenarios requiring high-performance IO.

documents/alfred/config/io-sync-off.md

@@ -0,0 +1,29 @@
+---
+title: IO Synchronization Off Utility
+documentation_of: ./src/alfred/config/io-sync-off.hpp
+---
+
+## Description
+
+This file provides a utility function to disable synchronization between C++ standard IO streams and C IO, which can significantly speed up input and output operations in C++ programs.
+
+## Usage Example
+
+```cpp
+#include "io-sync-off.hpp"
+optimizeIO();
+```
+
+## Main Features
+- Disables stdio and iostream synchronization
+- Unties cin/cout for faster IO
+
+## Important Functions and Time Complexity
+
+| Function     | Description                       | Time Complexity |
+| ------------ | --------------------------------- | --------------- |
+| `optimizeIO` | Disable IO sync and untie streams | $O(1)$          |
+
+## Notes
+- Should be called at the beginning of main() for effect.
+- Commonly used in competitive programming.

documents/alfred/data_structure/appear-statistics.md

@@ -0,0 +1,35 @@
+---
+title: Appear Statistics Data Structure
+documentation_of: ./src/alfred/data_structure/appear-statistics.hpp
+---
+
+## Description
+
+This file implements the `AppearStats` class, a data structure for efficiently tracking the positions and counts of occurrences of elements in a sequence, supporting fast queries for the first, last, and count of an element in a given range.
+
+## Usage Example
+
+```cpp
+#include "appear-statistics.hpp"
+std::vector<int> a = {1, 2, 1, 3, 2};
+AppearStats<int> stats(a);
+int first_pos = stats.first(0, 4, 2); // First occurrence of 2 in [0,4]
+int count = stats.count(0, 4, 1);     // Count of 1 in [0,4]
+```
+
+## Main Features
+- Tracks all positions of each unique element
+- Supports fast queries for first/last occurrence and count in a range
+- Uses discretization for efficient storage
+
+## Important Functions and Time Complexity
+
+| Function | Description                | Time Complexity |
+| -------- | -------------------------- | --------------- |
+| `first`  | First occurrence in range  | $O(\log n)$     |
+| `last`   | Last occurrence in range   | $O(\log n)$     |
+| `count`  | Count occurrences in range | $O(\log n)$     |
+
+## Notes
+- Useful for range queries on static arrays.
+- Indexing is flexible with a base parameter.

documents/alfred/data_structure/binary-trie.md

@@ -0,0 +1,55 @@
+---
+title: Binary Trie (01-Trie)
+documentation_of: ./src/alfred/data_structure/binary-trie.hpp
+---
+
+## Description
+
+This file implements a Binary Trie (01-Trie) data structure for efficiently storing and querying binary representations of integers. It supports insertion, minimum/maximum XOR queries, and range queries with upper bounds.
+
+本文件实现了支持下标和区间信息维护的 01-Trie（BinaryTrie），可用于集合异或最值、区间下标查询等。
+
+## Usage Example
+
+```cpp
+#include "binary-trie.hpp"
+BinaryTrie trie;
+trie.insert(5);
+uint64_t min_xor = trie.query_min(3);
+uint64_t max_xor = trie.query_max(3);
+```
+
+## Main Features
+- Insert and store integers in binary form
+- Query for minimum/maximum XOR with a given value
+- Query for values with XOR less than an upper bound
+- Maintains min/max index for range queries
+
+- 支持插入、异或最小/最大值查询
+- 支持下标区间信息维护
+- 支持 upper_bound 异或查询
+
+## Important Functions and Time Complexity
+
+| Function    | Description                   | Time Complexity |
+| ----------- | ----------------------------- | --------------- |
+| `insert`    | Insert integer into trie      | $O(B)$          |
+| `query_min` | Minimize XOR with given value | $O(B)$          |
+| `query_max` | Maximize XOR with given value | $O(B)$          |
+| `query_ub`  | Query for XOR < upper bound   | $O(B)$          |
+
+| Function    | Description        | Time Complexity |
+| ----------- | ------------------ | --------------- |
+| `insert`    | 插入一个数         | $O(\log V)$     |
+| `query_min` | 查询异或最小值     | $O(\log V)$     |
+| `query_max` | 查询异或最大值     | $O(\log V)$     |
+| `query_ub`  | 异或小于上界的区间 | $O(\log V)$     |
+
+Where $B$ is the number of bits (default 30).
+
+## Notes
+- Useful for problems involving XOR queries and binary representations.
+- Supports index tracking for advanced queries.
+
+- 适用于集合异或、区间最值等问题。
+- 支持维护插入元素的下标信息。

documents/alfred/data_structure/chtholly.md

@@ -0,0 +1,33 @@
+---
+title: Chtholly Tree Data Structure
+documentation_of: ./src/alfred/data_structure/chtholly.hpp
+---
+
+## Description
+
+This file implements the Chtholly Tree data structure, which is a set-based interval management structure supporting fast interval assignment, modification, and queries. It is commonly used for range updates and queries on intervals.
+
+## Usage Example
+
+```cpp
+#include "chtholly.hpp"
+ChthollyTree<int> tree(10, 0); // Range [0,10] initialized to 0
+tree.assign(2, 5, 3); // Set [2,5] to 3
+```
+
+## Main Features
+- Efficient interval splitting and assignment
+- Supports custom modification and query functions on intervals
+- Uses std::set for ordered interval management
+
+## Important Functions and Time Complexity
+
+| Function | Description                  | Time Complexity |
+| -------- | ---------------------------- | --------------- |
+| `assign` | Assign value to interval     | $O(\log n)$     |
+| `modify` | Modify interval with functor | $O(\log n)$     |
+| `query`  | Query interval with functor  | $O(\log n)$     |
+
+## Notes
+- Useful for range assignment and query problems.
+- Intervals are managed as [l, r] inclusive.

documents/alfred/data_structure/discretization.md

@@ -0,0 +1,50 @@
+---
+title: Discretization Utilities
+documentation_of: ./src/alfred/data_structure/discretization.hpp
+---
+
+## Description
+
+本文件实现了通用离散化工具类 `Mess`，用于将任意可比较类型的值映射到连续整数区间，便于后续高效处理。
+
+This file provides the Mess class, a utility for discretizing values in a vector, mapping them to a compact index range. It supports insertion, initialization, querying, and checking existence of values.
+
+## Usage Example
+
+```cpp
+#include "discretization.hpp"
+std::vector<int> a = {100, 200, 100};
+Mess<int> mess(a);
+int idx = mess.query(200); // 查询 200 离散化后的编号
+```
+
+```cpp
+#include "discretization.hpp"
+std::vector<int> a = {5, 2, 7};
+Mess<int> mess(a);
+int idx = mess.query(5); // Get discrete index of 5
+```
+
+## Main Features
+- 支持批量插入、自动去重排序
+- 支持原值与离散编号互查
+- 支持判断元素是否存在
+
+Discretizes values to compact indices
+Supports batch insertion and initialization
+Query for discrete index and check existence
+
+## Important Functions and Time Complexity
+
+| Function | Description        | Time Complexity |
+| -------- | ------------------ | --------------- |
+| `insert` | 插入元素           | $O(1)$          |
+| `init`   | 初始化（排序去重） | $O(n \log n)$   |
+| `query`  | 查询离散编号       | $O(\log n)$     |
+| `exist`  | 判断元素是否存在   | $O(\log n)$     |
+
+## Notes
+- 适用于需要离散化处理的场景。
+- 支持任意可比较类型。
+
+Useful for coordinate compression and mapping values to indices.

documents/alfred/data_structure/dsu/cancel-dsu.md

@@ -0,0 +1,41 @@
+---
+title: Cancelable Disjoint Set Union (DSU)
+documentation_of: ./src/alfred/data_structure/dsu/cancel-dsu.hpp
+---
+
+## Description
+
+本文件实现了支持撤销操作的并查集（Cancelable DSU），可用于可回溯的合并查找问题。
+
+This file implements a cancelable Disjoint Set Union (DSU) data structure, also known as a union-find with rollback. It supports merging sets, checking connectivity, and undoing previous merge operations efficiently.
+
+## Usage Example
+
+```cpp
+#include "cancel-dsu.hpp"
+CancelDSU dsu(5);
+dsu.merge(1, 2);
+dsu.cancel(); // 撤销上一次合并
+dsu.cancel(); // Undo last merge
+```
+
+## Main Features
+- 支持撤销合并操作
+- 支持集合大小查询
+- 适合可回溯并查集场景
+- Supports union, find, and size queries
+- Allows rollback (cancel) of previous merge operations
+- Maintains history using a stack
+
+## Important Functions and Time Complexity
+
+| Function | Description                         | Time Complexity |
+| -------- | ----------------------------------- | --------------- |
+| `merge`  | 合并集合                            | $O(\alpha(n))$  |
+| `cancel` | 撤销合并                            | $O(1)$          |
+| `find`   | 查找根节点                          | $O(\alpha(n))$  |
+| `same`   | Check if two elements are connected | $O(\alpha(n))$  |
+
+## Notes
+- 适用于需要撤销操作的并查集问题。
+- Useful for offline dynamic connectivity and backtracking problems.

documents/alfred/data_structure/dsu/dsu.md

@@ -0,0 +1,35 @@
+---
+title: Disjoint Set Union (DSU)
+documentation_of: ./src/alfred/data_structure/dsu/dsu.hpp
+---
+
+## Description
+
+This file implements the classic Disjoint Set Union (DSU) or Union-Find data structure, supporting efficient union, find, and size queries. It also provides a directed merge operation.
+
+## Usage Example
+
+```cpp
+#include "dsu.hpp"
+DSU dsu(5);
+dsu.merge(1, 2);
+bool connected = dsu.same(1, 2);
+```
+
+## Main Features
+- Supports union, find, and size queries
+- Provides both undirected and directed merge
+- Uses path compression and union by size
+
+## Important Functions and Time Complexity
+
+| Function         | Description                         | Time Complexity |
+| ---------------- | ----------------------------------- | --------------- |
+| `merge`          | Merge two sets                      | $O(\alpha(n))$  |
+| `find`           | Find representative                 | $O(\alpha(n))$  |
+| `same`           | Check if two elements are connected | $O(\alpha(n))$  |
+| `size`           | Get size of set                     | $O(1)$          |
+| `directed_merge` | Merge x into y (directed)           | $O(\alpha(n))$  |
+
+## Notes
+- Widely used for connectivity queries in graphs.