Add mathematical algorithms for combinatorics, prime sieving, searching techniques, and ternary search

- Implemented CombinationMod class for calculating binomial coefficients modulo p with various methods.
- Added Sieve of Eratosthenes and linear sieve for prime number generation.
- Included binary search algorithms for various use cases including finding boundaries and searching in rotated arrays.
- Implemented interpolation search for uniformly distributed sorted arrays.
- Added lower and upper bound functions for ordered arrays.
- Developed ternary search for finding extrema in unimodal functions and included examples for discrete and continuous cases.

Author: tkzzzzzz6

leetcode/Study Plan/3531. 统计被覆盖的建筑/1.cpp

@@ -0,0 +1,26 @@
+#include <algtorithm>
+#include <climits>
+#include <vector>
+using namespace std;
+class Solution {
+   public:
+    int countCoveredBuildings(int n, vector<vector<int>> &buildings) {
+        vector<int> row_min(n + 1, INT_MAX), row_max(n + 1);
+        vector<int> col_min(n + 1, INT_MAX), col_max(n + 1);
+        for (auto &b : buildings) {
+            int x = b[0], y = b[1];
+            row_min[y] = min(row_min[y], x);
+            row_max[y] = max(row_max[y], x);
+            col_min[x] = min(col_min[x], y);
+            col_max[x] = max(col_max[x], y);
+        }
+        int ans = 0;
+        for (auto &b : buildings) {
+            int x = b[0], y = b[1];
+
+            if (row_min[y] < x && row_max[y] > x && col_min[x] < y && col_max[x] > y)
+                ++ans;
+        }
+        return ans;
+    }
+};

niuke/daily_problem/25_12-11小红的矩阵/1.cpp

@@ -58,9 +58,9 @@ il void solve() {
 }
 
 int main() {
-    fastio // 快速输入输出
+    fastio; // 快速输入输出
 
-        int t = 1;
+    int t = 1;
     // cin >> t;  // 多组测试数据时取消注释
     while (t--) {
         solve();

template/README.md

@@ -0,0 +1,150 @@
+# 算法竞赛模板库
+
+这是一个为算法竞赛准备的 C++ 模板库，包含了常见的数据结构和算法实现。
+
+## 📁 目录结构
+
+```
+template/
+├── data-structures/     # 数据结构
+├── graphs/             # 图算法
+├── math/               # 数学算法
+├── searching/          # 搜索算法
+├── dynamic_programming/ # 动态规划
+├── strings/            # 字符串算法
+└── README.md           # 本文件
+```
+
+## 📚 内容索引
+
+### 数据结构 (data-structures/)
+
+| 文件 | 内容 | 时间复杂度 |
+|------|------|-----------|
+| [segment_tree.cpp](data-structures/segment_tree.cpp) | 线段树（区间查询与修改） | 查询/修改: O(log n) |
+| [fenwick_tree.cpp](data-structures/fenwick_tree.cpp) | 树状数组（前缀和） | 查询/修改: O(log n) |
+| [union_find.cpp](data-structures/union_find.cpp) | 并查集（动态连通性） | find/union: O(α(n)) |
+| [sparse_table.cpp](data-structures/sparse_table.cpp) | 稀疏表（RMQ问题） | 预处理: O(n log n), 查询: O(1) |
+| [trie.cpp](data-structures/trie.cpp) | 字典树（字符串检索） | 插入/查询: O(L) |
+
+### 图算法 (graphs/)
+
+| 文件 | 内容 | 时间复杂度 |
+|------|------|-----------|
+| [dfs.cpp](graphs/dfs.cpp) | 深度优先搜索 | O(V + E) |
+| [bfs.cpp](graphs/bfs.cpp) | 广度优先搜索 | O(V + E) |
+| [dijkstra.cpp](graphs/dijkstra.cpp) | Dijkstra最短路径 | O((V + E) log V) |
+| [bellman_ford.cpp](graphs/bellman_ford.cpp) | Bellman-Ford最短路径 | O(VE) |
+| [floyd_warshall.cpp](graphs/floyd_warshall.cpp) | Floyd-Warshall全源最短路径 | O(V³) |
+| [topological_sort.cpp](graphs/topological_sort.cpp) | 拓扑排序 | O(V + E) |
+| [strongly_connected_components.cpp](graphs/strongly_connected_components.cpp) | 强连通分量 | O(V + E) |
+| [kruskal.cpp](graphs/kruskal.cpp) | Kruskal最小生成树 | O(E log E) |
+
+### 数学算法 (math/)
+
+| 文件 | 内容 | 时间复杂度 |
+|------|------|-----------|
+| [prime_sieve.cpp](math/prime_sieve.cpp) | 埃拉托斯特尼筛法（素数筛） | O(n log log n) |
+| [gcd_lcm.cpp](math/gcd_lcm.cpp) | 最大公约数与最小公倍数 | O(log min(a,b)) |
+| [extended_euclidean.cpp](math/extended_euclidean.cpp) | 扩展欧几里得算法 | O(log min(a,b)) |
+| [matrix_exponentiation.cpp](math/matrix_exponentiation.cpp) | 矩阵快速幂 | O(n³ log k) |
+| [nCr_mod.cpp](math/nCr_mod.cpp) | 组合数取模 | 预处理: O(n), 查询: O(1) |
+| [modular_inverse.cpp](math/modular_inverse.cpp) | 模逆元 | O(log m) |
+
+### 搜索算法 (searching/)
+
+| 文件 | 内容 | 时间复杂度 |
+|------|------|-----------|
+| [binary_search.cpp](searching/binary_search.cpp) | 二分查找 | O(log n) |
+| [ternary_search.cpp](searching/ternary_search.cpp) | 三分查找 | O(log n) |
+| [lower_upper_bound.cpp](searching/lower_upper_bound.cpp) | 边界查找 | O(log n) |
+| [interpolation_search.cpp](searching/interpolation_search.cpp) | 插值查找 | 平均: O(log log n) |
+
+### 动态规划 (dynamic_programming/)
+
+| 文件 | 内容 | 时间复杂度 |
+|------|------|-----------|
+| [knapsack.cpp](dynamic_programming/knapsack.cpp) | 背包问题合集 | O(nW) |
+| [longest_common_subsequence.cpp](dynamic_programming/longest_common_subsequence.cpp) | 最长公共子序列 | O(mn) |
+| [longest_increasing_subsequence.cpp](dynamic_programming/longest_increasing_subsequence.cpp) | 最长递增子序列 | O(n log n) |
+| [matrix_chain_multiplication.cpp](dynamic_programming/matrix_chain_multiplication.cpp) | 矩阵链乘法 | O(n³) |
+| [coin_change.cpp](dynamic_programming/coin_change.cpp) | 零钱兑换 | O(amount × n) |
+
+### 字符串算法 (strings/)
+
+| 文件 | 内容 | 时间复杂度 |
+|------|------|-----------|
+| [knuth_morris_pratt.cpp](strings/knuth_morris_pratt.cpp) | KMP字符串匹配 | O(n + m) |
+| [z_algorithm.cpp](strings/z_algorithm.cpp) | Z算法 | O(n) |
+| [suffix_array.cpp](strings/suffix_array.cpp) | 后缀数组 | O(n log n) |
+| [rabin_karp.cpp](strings/rabin_karp.cpp) | Rabin-Karp算法 | 平均: O(n + m) |
+| [string_hashing.cpp](strings/string_hashing.cpp) | 字符串哈希 | 预处理: O(n), 查询: O(1) |
+
+## 🚀 使用方法
+
+1. **直接复制**：将需要的模板代码复制到你的解题代码中
+2. **学习参考**：每个文件都包含详细的注释和使用示例
+3. **修改适配**：根据具体题目要求调整模板代码
+
+### 使用示例
+
+```cpp
+#include <bits/stdc++.h>
+using namespace std;
+
+// 复制你需要的模板代码
+class UnionFind {
+    // ... 模板代码 ...
+};
+
+int main() {
+    // 使用模板解题
+    UnionFind uf(100);
+    uf.unite(1, 2);
+    cout << uf.connected(1, 2) << endl;
+
+    return 0;
+}
+```
+
+## 📝 代码规范
+
+- 所有模板使用 C++11 及以上标准
+- 采用算法竞赛常用的编码风格
+- 每个文件包含：
+  - 算法说明和用途
+  - 时间/空间复杂度分析
+  - 完整的实现代码
+  - 使用示例
+
+## 🎯 适用场景
+
+- **算法竞赛**：ACM-ICPC、Codeforces、AtCoder等
+- **在线评测**：LeetCode、洛谷、牛客网等
+- **学习练习**：算法学习和面试准备
+
+## ⚠️ 注意事项
+
+1. **MOD值**：某些模板使用 `1e9+7` 作为模数，根据题目要求修改
+2. **数据范围**：注意整型溢出，必要时使用 `long long`
+3. **输入输出**：模板仅提供核心算法，需自行处理输入输出
+4. **测试验证**：使用前请在样例上测试验证
+
+## 📖 学习资源
+
+- [OI Wiki](https://oi-wiki.org/)
+- [CP-Algorithms](https://cp-algorithms.com/)
+- [Codeforces](https://codeforces.com/)
+- [LeetCode](https://leetcode.com/)
+
+## 🔄 更新日志
+
+- 2025-12-11: 初始版本，包含基础数据结构和算法模板
+
+## 📧 反馈建议
+
+如有问题或建议，欢迎提出 Issue 或 Pull Request。
+
+---
+
+**Happy Coding! 祝你在算法竞赛中取得好成绩！** 🎉

template/archtecture.md

@@ -0,0 +1,144 @@
+在算法仓库中组织和管理模板文件夹的结构，良好的排布不仅有助于提高效率，还能让自己和其他人更容易找到所需要的模板。这里是我为你推荐的一个清晰、易于维护的目录结构设计：
+
+### 推荐的文件夹结构
+
+```
+/algorithm-templates
+├── /data-structures
+│   ├── segment_tree.cpp
+│   ├── fenwick_tree.cpp
+│   ├── union_find.cpp
+│   ├── disjoint_set_union.cpp
+│   ├── sparse_table.cpp
+│   ├── trie.cpp
+│   └── queue.cpp
+├── /graphs
+│   ├── dfs.cpp
+│   ├── bfs.cpp
+│   ├── dijkstra.cpp
+│   ├── bellman_ford.cpp
+│   ├── floyd_warshall.cpp
+│   ├── topological_sort.cpp
+│   ├── strongly_connected_components.cpp
+│   └── kruskal.cpp
+├── /math
+│   ├── prime_sieve.cpp
+│   ├── gcd_lcm.cpp
+│   ├── extended_euclidean.cpp
+│   ├── matrix_exponentiation.cpp
+│   ├── nCr_mod.cpp
+│   └── modular_inverse.cpp
+├── /searching
+│   ├── binary_search.cpp
+│   ├── ternary_search.cpp
+│   ├── lower_upper_bound.cpp
+│   └── interpolation_search.cpp
+├── /dynamic_programming
+│   ├── knapsack.cpp
+│   ├── longest_common_subsequence.cpp
+│   ├── longest_increasing_subsequence.cpp
+│   ├── matrix_chain_multiplication.cpp
+│   └── coin_change.cpp
+├── /strings
+│   ├── knuth_morris_pratt.cpp
+│   ├── z_algorithm.cpp
+│   ├── suffix_array.cpp
+│   ├── rabin_karp.cpp
+│   ├── trie.cpp
+│   └── string_hashing.cpp
+└── README.md
+```
+
+### 解释各个文件夹和文件：
+
+#### 1. **`data-structures/`（数据结构）**
+
+这个文件夹用于存放各种常见的数据结构实现，以下是一些常见的数据结构和它们对应的模板文件：
+
+* **`segment_tree.cpp`**：线段树模板（用于区间查询和修改）。
+* **`fenwick_tree.cpp`**：树状数组模板（又叫做 Binary Indexed Tree，适用于区间求和）。
+* **`union_find.cpp`**：并查集模板（用于处理动态连通性问题）。
+* **`disjoint_set_union.cpp`**：并查集（常用的实现方式）。
+* **`sparse_table.cpp`**：稀疏表模板（通常用于区间最小值查询）。
+* **`trie.cpp`**：字典树模板（用于字符串匹配问题）。
+* **`queue.cpp`**：常见队列和优先队列的实现。
+
+#### 2. **`graphs/`（图算法）**
+
+这个文件夹存放图相关的算法模板，主要涉及图的遍历、最短路径、最小生成树等：
+
+* **`dfs.cpp`**：深度优先搜索模板。
+* **`bfs.cpp`**：广度优先搜索模板。
+* **`dijkstra.cpp`**：Dijkstra最短路径算法模板。
+* **`bellman_ford.cpp`**：Bellman-Ford最短路径算法模板（可以处理负权边）。
+* **`floyd_warshall.cpp`**：Floyd-Warshall全源最短路径算法模板。
+* **`topological_sort.cpp`**：拓扑排序模板。
+* **`strongly_connected_components.cpp`**：强连通分量模板（用于图的分解）。
+* **`kruskal.cpp`**：Kruskal最小生成树算法模板。
+
+#### 3. **`math/`（数学算法）**
+
+存放常见的数学算法模板，通常用于处理数论相关问题：
+
+* **`prime_sieve.cpp`**：埃拉托斯特尼筛法模板（用来找素数）。
+* **`gcd_lcm.cpp`**：最大公约数和最小公倍数算法模板。
+* **`extended_euclidean.cpp`**：扩展欧几里得算法模板（用于求解线性同余方程）。
+* **`matrix_exponentiation.cpp`**：矩阵快速幂模板。
+* **`nCr_mod.cpp`**：计算组合数的模。
+* **`modular_inverse.cpp`**：求解模逆元的算法模板。
+
+#### 4. **`searching/`（搜索算法）**
+
+存放常见的搜索算法模板：
+
+* **`binary_search.cpp`**：二分查找模板。
+* **`ternary_search.cpp`**：三分查找模板。
+* **`lower_upper_bound.cpp`**：寻找下界和上界模板。
+* **`interpolation_search.cpp`**：插值查找模板。
+
+#### 5. **`dynamic_programming/`（动态规划）**
+
+这个文件夹用于存放动态规划的经典模板：
+
+* **`knapsack.cpp`**：01背包问题模板。
+* **`longest_common_subsequence.cpp`**：最长公共子序列模板。
+* **`longest_increasing_subsequence.cpp`**：最长递增子序列模板。
+* **`matrix_chain_multiplication.cpp`**：矩阵链乘法模板。
+* **`coin_change.cpp`**：零钱兑换问题模板。
+
+#### 6. **`strings/`（字符串算法）**
+
+存放常见的字符串算法模板：
+
+* **`knuth_morris_pratt.cpp`**：KMP字符串匹配算法模板。
+* **`z_algorithm.cpp`**：Z算法模板（用于字符串模式匹配）。
+* **`suffix_array.cpp`**：后缀数组模板。
+* **`rabin_karp.cpp`**：Rabin-Karp字符串匹配算法模板。
+* **`trie.cpp`**：字典树（前面已提到）。
+* **`string_hashing.cpp`**：字符串哈希模板（用于快速查找子串）。
+
+#### 7. **`README.md`**
+
+* 用于简单描述整个仓库的结构和如何使用这些模板。可以包括如何添加新的模板，如何使用这些模板解决问题，等等。
+
+---
+
+### 为什么这样排布：
+
+1. **按算法类型分目录**：将相关的模板文件归类在一起，如“图算法”、“数学算法”、“字符串算法”等。这样有助于你快速找到相关的模板，避免在一个文件夹中查找所有的模板。
+
+2. **便于扩展**：随着你学习的进展，你可能会增加新的算法或者数据结构，这种结构便于你后续拓展，不需要重构整个仓库。
+
+3. **模块化管理**：这种按功能分组的方式可以帮助你保持仓库的整洁，避免模板过多时显得凌乱。
+
+---
+
+### 提示：
+
+1. **注释和文档**：确保每个模板文件开头有清晰的注释，简单说明这个模板解决了什么问题，如何使用。你也可以为每个文件添加例子，说明其应用场景。
+
+2. **命名规范**：文件名可以采用简单且直观的命名方式，便于自己和他人理解。例如，`dfs.cpp` 表示深度优先搜索，`segment_tree.cpp` 表示线段树，等等。
+
+3. **版本控制**：如果你的模板库有多人合作或者想长期维护，建议使用 Git 进行版本控制。
+
+