#include<bits/stdc++.h> usingnamespace std; using ll = longlong; constexprint mod = 1e9 + 7, maxn = 1e6 + 5;
ll t, fac[maxn], ifac[maxn], sum[maxn];
ll qpow(ll a, ll b){ ll res = 1; a %= mod; while (b) { if (b & 1) { res = res * a % mod; } a = a * a % mod; b >>= 1; } return res; }
voidinit(){ fac[0] = 1; for (int i = 1; i < maxn; ++i) { fac[i] = fac[i - 1] * i % mod; } ifac[maxn - 1] = qpow(fac[maxn - 1], mod - 2) % mod; for (int i = maxn - 2; i >= 0; --i) { ifac[i] = ifac[i + 1] * (i + 1) % mod; } for (int i = 1; i < maxn; ++i) { sum[i] = (sum[i - 1] + ifac[i]) % mod; } }
ll ans(int n, int m){ return (1ll * n * fac[n - m] % mod - sum[m - 1] % mod + mod) % mod * fac[m] % mod; }
intmain(){ ios::sync_with_stdio(false); cin.tie(nullptr); init(); cin >> t; while (t--) { int n, m; cin >> n >> m; cout << ans(n, m) << '\n'; } return0; }
]]>
https://nine19een.com/writing/2026/07/12/CCPC-2021-Online-H-subpermutation-review/2026-07-12T15:47:41.000Z将完整全排列串中的合法连续段拆成排列内部与相邻排列边界两类，利用字典序后继的最长下降后缀计数，得到只需阶乘和逆阶乘前缀和的闭式。CCPC 2021 Online - H 复盘：排列边界与逆阶乘求和2026-07-12T15:47:41.000Znine19een前言
longlongqpow(longlong a, longlong b){ longlong res = 1; a %= MOD; while (b) { if (b & 1) res = res * a % MOD; a = a * a % MOD; b >>= 1; } return res; }
voidinit(int N){ fac[0] = 1; for (int i = 1; i <= N; ++i) { fac[i] = fac[i - 1] * i % MOD; } ifac[N] = qpow(fac[N], MOD - 2); for (int i = N - 1; i >= 0; --i) { ifac[i] = ifac[i + 1] * (i + 1) % MOD; } }
longlongC(int n, int k){ if (k < 0 || k > n) return0; return fac[n] * ifac[k] % MOD * ifac[n - k] % MOD; }
适用边界
这个模板适用于：
MOD 是质数；
需要预处理的最大 N 不太大；
普通阶乘中没有遇到更复杂的 n≥MOD 情形。
如果 n 极大，或者 n≥MOD 后阶乘中含有模数因子，就不能简单套这个模板。那属于 Lucas 定理等更一般的内容，本文不展开。
错排模型
错排指的是：有 n 个元素，每个元素都不能放回原来的位置，问有多少种排列方式。
记错排数为：
Dn
常用初值为：
D0=1,D1=0
递推式为：
Dn=(n−1)(Dn−1+Dn−2)
递推推导
考虑第 n 个元素。
它不能放在自己的位置，所以它可以放到前 n−1 个位置中的任意一个。假设它放到了位置 k，其中：
1≤k≤n−1
接下来考虑原本应该放在位置 k 的元素。
设第 k 个元素为 k。
当 n 放到了位置 k 后，元素 k 有两种情况。
情况一：元素 k 放到位置 n
也就是 k 和 n 互换位置。
此时这两个元素的位置已经确定：
n 放到 k 的位置；
k 放到 n 的位置。
剩下 n−2 个元素仍然需要全部错排，所以方案数为：
Dn−2
情况二：元素 k 不放到位置 n
此时可以把位置 n 看成“原来属于 k 的禁位”。
换句话说，除去元素 n 后，剩下 n−1 个元素仍然形成一个错排问题：每个元素都不能放到自己的对应禁位上。
这部分方案数为：
Dn−1
对于第 n 个元素，它一共有 n−1 种选择位置的方式。因此总数为：
Dn=(n−1)(Dn−1+Dn−2)
模板
1 2 3 4 5
D[0] = 1; D[1] = 0; for (int i = 2; i <= N; ++i) { D[i] = (i - 1) * (D[i - 1] + D[i - 2]) % MOD; }
int n, m, cnt; vector<int> adj[maxn]; bool vis[maxn];
voidBFS(int s){ queue<int> q; q.push(s); vis[s] = true; while (!q.empty()) { int u = q.front(); q.pop(); for (int v: adj[u]) { if (!vis[v]) { q.push(v); vis[v] = true; } } } }
intmain(){ ios::sync_with_stdio(false); cin.tie(nullptr); cin >> n >> m; for (int i = 1; i <= m; i++) { int a, b; cin >> a >> b; adj[a].push_back(b); adj[b].push_back(a); } for (int i = 1; i <= n; ++i) { if (!vis[i]) { cnt++; BFS(i); } } int new_edges = cnt - 1; int mx = (new_edges * 2 + n - 1) / n; cout << new_edges << " " << mx; return0; }
int n, d[maxn], pre0[maxn], a[maxn], b[maxn], ans; unordered_map<int, vector<int> > um;
intansOFk(const vector<int> &pos){ int base = pre0[n]; if (pos.size() == 1) { return base + 1; } int cur = 1, best = 1; for (auto it = next(pos.begin()); it != pos.end(); ++it) { cur = max(1, cur + 1 - pre0[*it - 1] + pre0[*prev(it)]); best = max(best, cur); } return base + best; }
intmain(){ ios::sync_with_stdio(false); cin.tie(nullptr); cin >> n; for (int i = 1; i <= n; ++i) { cin >> a[i]; } for (int i = 1; i <= n; ++i) { cin >> b[i]; d[i] = b[i] - a[i]; pre0[i] = pre0[i - 1] + (d[i] == 0); if (d[i]) { um[d[i]].push_back(i); } } ans = pre0[n]; for (constauto &p: um) { ans = max(ans, ansOFk(p.second)); } cout << ans; return0; }
]]>
https://nine19een.com/writing/2026/05/12/lanqiao-2026-provincial-review/2026-05-11T19:00:00.000Z记录蓝桥杯 2026 省赛 B 组从考前准备、考场决策到赛后重做的完整复盘，重点分析每题的考场思路、正解推导、失误原因与可迁移经验。蓝桥杯 2026 省赛 B 组复盘：考前状态、考场决策与赛后重做2026-05-11T19:00:00.000Znine19een前言
#include<bits/stdc++.h> usingnamespace std; using ll = longlong;
constexpr ll maxn = 2e5 + 5;
structQuery { int l, r, id; };
structFenwick { int n; vector<int> c;
Fenwick(int _n) : n(_n), c(n + 1, 0) { }
staticintlowbit(int x){ return x & -x; }
voidadd(int x){ for (int i = x; i <= n; i += lowbit(i)) { c[i]++; } }
[[nodiscard]] intquery(int x)const{ int sum = 0; for (int i = x; i; i -= lowbit(i)) { sum += c[i]; } return sum; } };
int n, m, q; bool ans[maxn]; vector<int> L[maxn], R[maxn]; vector<Query> Q; unordered_set<ll> exact_LR;
voidinit(){ for (int i = 1; i <= n; i++) { if (!L[i].empty()) { sort(L[i].begin(), L[i].end()); } if (!R[i].empty()) { sort(R[i].begin(), R[i].end()); } } sort(Q.begin(), Q.end(), [](const Query &a, const Query &b) { return a.l > b.l; }); }
ll Key(int l, int r){ return1ll * l * maxn + r; }
boolJoint(int l, int r){ if (L[l].empty() || R[r].empty()) { returnfalse; } auto it_r = lower_bound(L[l].begin(), L[l].end(), r); auto it_l = upper_bound(R[r].begin(), R[r].end(), l); if (it_r == L[l].begin() || it_l == R[r].end()) { returnfalse; } --it_r; return *it_r + 1 >= *it_l; }
boolExact(int l, int r, const Fenwick &bit){ if (!exact_LR.count(Key(l, r))) { returnfalse; } return bit.query(r) > 1; }
voidSolve(){ Fenwick bit(n); int cur_L = n; for (Query qy: Q) { while (cur_L >= qy.l) { for (int r: L[cur_L]) { bit.add(r); } cur_L--; } if (Joint(qy.l, qy.r) || Exact(qy.l, qy.r, bit)) { ans[qy.id] = true; } } }
voidprintANS(){ for (int i = 1; i <= q; i++) { cout << (ans[i] ? "Yes\n" : "No\n"); } }
intmain(){ ios::sync_with_stdio(false); cin.tie(nullptr); cin >> n >> m; for (int i = 1; i <= m; i++) { int l, r; cin >> l >> r; L[l].push_back(r); R[r].push_back(l); exact_LR.insert(Key(l, r)); } cin >> q; for (int i = 1; i <= q; i++) { int s, t; cin >> s >> t; Q.push_back({s, t, i}); } init(); Solve(); printANS(); return0; }
voidInsert(int x){ int p = 0; for (int i = 25; i >= 0; --i) { int v = x >> i & 1; if (!trie[p][v]) { trie[p][v] = ++idx; } p = trie[p][v]; cnt[p]++; } }
从高位到低位依次取出每一位：
若对应儿子不存在，则新建节点
沿路径向下走
将经过节点的计数加一
插入完成后，x 所在路径上的所有节点计数均被正确维护。
2. 删除
1 2 3 4 5 6 7 8
voidDelete(int x){ int p = 0; for (int i = 25; i >= 0; --i) { int v = x >> i & 1; p = trie[p][v]; cnt[p]--; } }
删除时沿原路径走一遍，并将沿途 cnt 减一即可。 不必真正删除节点，只需保证计数正确。
该写法默认题目保证删除操作合法，即待删除元素一定存在。
七、排名查询 getRank
代码如下：
1 2 3 4 5 6 7 8 9 10 11 12 13 14
intgetRank(int x){ int p = 0, rank = 0; for (int i = 25; i >= 0; --i) { int v = x >> i & 1; if (v) { rank += cnt[trie[p][0]]; } p = trie[p][v]; if (!p) { break; } } return rank; }
该函数返回的不是题目中的“排名”，而是：
严格小于 x 的元素个数
因此主函数中查询排名时需要输出：
1
getRank(x + offset) + 1
正确性分析
从高位到低位考虑当前位。
设当前位为 v：
当 v = 0
若某个数在当前位取 1，则在高位前缀相同的前提下，它一定大于 x。 因此不会对“小于 x 的元素个数”产生贡献，直接沿 0 分支继续即可。
当 v = 1
此时，所有高位前缀与 x 相同、但当前位取 0 的数，一定严格小于 x。 因此可以直接累计：
1
rank += cnt[trie[p][0]];
随后继续沿 1 分支向下，统计剩余部分。
提前退出
若某一步 p 变为 0，说明当前前缀已不存在，后续更低位不可能再产生贡献，可以直接结束。
八、第 k 小查询 getVal
代码如下：
1 2 3 4 5 6 7 8 9 10 11 12 13
intgetVal(int x){ int p = 0, val = 0; for (int i = 25; i >= 0; --i) { if (cnt[trie[p][0]] >= x) { p = trie[p][0]; } else { x -= cnt[trie[p][0]]; p = trie[p][1]; val |= 1 << i; } } return val; }
voidInsert(int x){ int p = 0; for (int i = 25; i >= 0; --i) { int v = x >> i & 1; if (!trie[p][v]) { trie[p][v] = ++idx; } p = trie[p][v]; cnt[p]++; } }
voidDelete(int x){ int p = 0; for (int i = 25; i >= 0; --i) { int v = x >> i & 1; p = trie[p][v]; cnt[p]--; } }
intgetRank(int x){ int p = 0, rank = 0; for (int i = 25; i >= 0; --i) { int v = x >> i & 1; if (v) { rank += cnt[trie[p][0]]; } p = trie[p][v]; if (!p) { break; } } return rank; }
intgetVal(int x){ int p = 0, val = 0; for (int i = 25; i >= 0; --i) { if (cnt[trie[p][0]] >= x) { p = trie[p][0]; } else { x -= cnt[trie[p][0]]; p = trie[p][1]; val |= 1 << i; } } return val; }
]]>
https://nine19een.com/writing/2025/10/13/K-InversePairs/2025-10-12T17:49:00.000Z复盘逆序 k 倍对问题，从普通逆序对模板出发，分析判断条件变化对查询边界与离散化集合的影响，并总结树状数组模板改造的关键思路。逆序 k 倍对 复盘：树状数组模板的查询边界改造2025-10-12T17:49:00.000Znine19een前言
本题由某位BUAA大佬分享。
初见这道图形题时，我被其酷似分形的演变过程所吸引。它看似是一个纯粹的图形模拟题，但随着操作次数 n 的增加，图形的尺寸和复杂性都呈爆炸式增长，让我意识到简单的暴力绘制绝非正解。本文旨在复盘我如何从繁杂的图形变化中发现并实现一个精妙的递推关系，最终优雅地解决这个问题的全过程。
题目
背景
丁香花通常由四片花瓣组成，四片花瓣的位置关系可以简要用图1表示。
单单四个正方形显然还不能表达丁香花的魅力，因此我们将该图形进行一次操作，包含以下两个步骤：
将图形重复4次，如图2所示；
将图形旋转45度，如图3所示。
我们将上述两个步骤整体称为一次操作。在图3基础上再重复一次操作，我们就能得到图4。
图1: 基础图形
图2: 基础图形重复四次
图3: 进行一次操作后
图4: 进行两次操作后
描述
本题需要你编程绘出进行了 n 次操作后的图形（注意：基础图形为进行了 0 次操作的图形）。
输出时，图形中有正方形的位置输出一个字符 o，没有正方形的位置输出一个空格 。行末的空格可以忽略。
例如，对于图1 (n=0)，应该输出为：
1 2 3
o o o o
又如，对于图4 (n=2)，应该输出为：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o
existing_entries = load_existing_entries(README_FILE_PATH) existing_filenames = set(unquote(re.search(r'/main/(.*)\)', entry['row']).group(1)) for entry in existing_entries if re.search(r'/main/(.*)\)', entry['row']))
print(f"Found {len(existing_entries)} existing entries in README.")
all_entries = existing_entries
ifnot os.path.isdir(SOURCE_CODE_PATH): print(f"Error: Source code directory '{SOURCE_CODE_PATH}' not found.") return
print(f"\n--- Scanning for new source files in {SOURCE_CODE_PATH} ---")
all_cpp_files = sorted([f for f in os.listdir(SOURCE_CODE_PATH) if f.endswith(".cpp")]) new_files_processed = 0
for filename in all_cpp_files: if filename in existing_filenames: continue
print(f" - Processing new file: {filename}") new_files_processed += 1
try: withopen(OUTPUT_FILENAME, 'w', encoding='utf-8') as f: f.write("| Date | Problem | Difficulty | Solution |\n") f.write("| :--------- | :--------------------------------------------------------- | :----------------------------------------------------------------------------------------------------------- | :---------------------------------------------------------------------------------------- |\n") for entry in all_entries: f.write(entry['row'] + '\n')
print("\n" + "="*50) print(f"Success! The complete and sorted table has been saved to:") print(f"{os.path.abspath(OUTPUT_FILENAME)}") print("Please copy the entire content of this file and replace the old table in your README.") print("="*50) except Exception as e: print(f"\nError! Failed to write output file: {e}")
