0103abc 的网站

AGC047E Product Simulation 题解

Wed, 04 Nov 2026 09:44:00 GMT

先不管 A=B=0A=B=0A=B=0 的情况，构造 A3=1A_3=1A3=1 只需要做比较 1=[0<A0+A1]1=[0<A_0+A_1]1=[0<A0+A1] 然后自己加自己就可以构造出 222 的幂次。然后拆二进制位，从高位到低位考虑 AAA 并维护已经确定的高位和 sss 则第 iii 位的值可以被表示为 bi=[s+2i<A+1]b_i=[s+2^i<A+1]bi=[s+2i<A+1] 然后顺便维护 sss 即可。

对每个二进制位分别考虑，设当前位的两个值为 x,y∈{0,1}x,y\in\lbrace0,1\rbracex,y∈{0,1} 则 xy=[1<x+y]xy=[1<x+y]xy=[1<x+y] 直接做一下比较即可，最后考虑合并二进制位信息，模拟高精度乘法可得 AB=∑i,j(Ai∧Bj)2i+jAB=\sum\limits_{i,j}(A_i\land B_j)2^{i+j}AB=i,j∑(Ai∧Bj)2i+j，得到 Ai∧BjA_i\land B_jAi∧Bj 的值之后直接自己和自己加 i+ji+ji+j 次即可。看着用的结点数量和步数都特别多但是限制条件太松了怎么写都能过（我的实现用了 299432994329943 次操作）。我也不知道这个为啥是银牌题。

写的时候可能需要逻辑清晰一些，建议给操作稍微封装一下。

namespace lowspeed_song {

mt19937_64 mt(time(0));

inline void init() {
}

int idx = 3;

inline int newnode() { return idx++; }

vector<tuple<char, int, int, int>> ops;

inline void add(int x, int y, int z) { ops.emplace_back('+', x, y, z); }
inline void leq(int x, int y, int z) { ops.emplace_back('<', x, y, z); }

int pwr[30], bit[2][30], O;

inline void getbit(int val, int b[30]) {
    int lim = newnode(), s = newnode(), _ = newnode();
    add(val, O, lim); for (int i = 29; ~i; --i) {
        int val = newnode(); b[i] = newnode();
        add(s, pwr[i], val), leq(val, lim, b[i]), add(b[i], 2, _);
        for (int j = 0; j < i; ++j) add(_, _, _);
        add(s, _, s);
    }
}

inline void mul() {
    int t = newnode();
    for (int i = 0; i < 30; ++i) for (int j = 0; j < 30; ++j) {
        add(bit[0][i], bit[1][j], t), leq(O, t, t);
        for (int k = 0; k < i + j; ++k) add(t, t, t);
        add(2, t, 2);
    }
}

inline void sol([[maybe_unused]]int __testcase_id, [[maybe_unused]]int __testcase_sum) {
    int _ = newnode(); O = newnode();
    add(0, 1, _), leq(2, _, O), pwr[0] = O;
    for (int i = 1; i < 30; ++i) pwr[i] = newnode(), add(pwr[i - 1], pwr[i - 1], pwr[i]);
    getbit(0, bit[0]), getbit(1, bit[1]), mul();
    cout << ops.size() << '\n';
    for (auto &[x, y, z, w] : ops) cout << x << ' ' << y << ' ' << z << ' ' << w << '\n';
}

} // namespace lowspeed_song

AGC041C Domino Quality 题解

Wed, 04 Nov 2026 09:42:00 GMT

套路的拆分信息，注意到如果一个 n×nn\times nn×n 和一个 m×mm\times mm×m 的合法构造每一行上的骨牌数相同，则可以一个放在左上角一个放在右下角合并成一个新的骨牌数不变的 (n+m)×(n+m)(n+m)\times(n+m)(n+m)×(n+m) 的合法构造。打个表发现 4×4,5×5,6×6,7×74\times 4,5\times 5,6\times 6,7\times 74×4,5×5,6×6,7×7 都可以构造出每一行每一列都是 333 个骨牌覆盖的合法构造，然后直接用 4×44\times 44×4 矩阵作为基底构造，剩下的边界情况用另外三个矩阵覆盖一下即可。需要特判 n=2n=2n=2 无解，n=3n=3n=3 搜出来一个构造即可。

代码特别好吃。

namespace lowspeed_song {

mt19937_64 mt(time(0));

inline void init() {
}

inline void sol([[maybe_unused]]int __testcase_id, [[maybe_unused]]int __testcase_sum) {
    int n; cin >> n;
    if (n == 2) cout << -1 << '\n';
    else if (n == 3) {
        cout << "a..\n";
        cout << "a..\n";
        cout << ".bb\n";
    } else if (n == 4) {
        cout << "aabc\n";
        cout << "ddbc\n";
        cout << "efgg\n";
        cout << "efhh\n";
    } else if (n == 5) {
        cout << "aabcc\n";
        cout << "ddb.e\n";
        cout << "ffgge\n";
        cout << "..hij\n";
        cout << "..hij\n";
    } else if (n == 6) {
        cout << "ab.c..\n";
        cout << "ab.c..\n";
        cout << "d.e.ff\n";
        cout << "d.eg..\n";
        cout << ".hhgii\n";
        cout << "jjkkll\n";
    } else if (n == 7) {
        cout << "a.bbcc.\n";
        cout << "add...e\n";
        cout << "..f.gge\n";
        cout << "hhf...i\n";
        cout << ".j.k..i\n";
        cout << "lj.k...\n";
        cout << "l..mmnn\n";
    } else {
        if (n % 4 == 0) {
            for (int i = 0; i < n / 4; ++i, cout << '\n') {
                for (int j = 0; j < i; ++j) cout << "....";
                cout << "aabc";
                for (int j = i; j < n / 4 - 1; ++j) cout << "....";
                cout << '\n';
                for (int j = 0; j < i; ++j) cout << "....";
                cout << "ddbc";
                for (int j = i; j < n / 4 - 1; ++j) cout << "....";
                cout << '\n';
                for (int j = 0; j < i; ++j) cout << "....";
                cout << "efgg";
                for (int j = i; j < n / 4 - 1; ++j) cout << "....";
                cout << '\n';
                for (int j = 0; j < i; ++j) cout << "....";
                cout << "efhh";
                for (int j = i; j < n / 4 - 1; ++j) cout << "....";
            }
        } else if (n % 4 == 1) {
            for (int i = 0; i < n / 4 - 1; ++i, cout << '\n') {
                for (int j = 0; j < i; ++j) cout << "....";
                cout << "aabc";
                for (int j = i; j < n / 4 - 1; ++j) cout << "....";
                cout << ".";
                cout << '\n';
                for (int j = 0; j < i; ++j) cout << "....";
                cout << "ddbc";
                for (int j = i; j < n / 4 - 1; ++j) cout << "....";
                cout << ".";
                cout << '\n';
                for (int j = 0; j < i; ++j) cout << "....";
                cout << "efgg";
                for (int j = i; j < n / 4 - 1; ++j) cout << "....";
                cout << ".";
                cout << '\n';
                for (int j = 0; j < i; ++j) cout << "....";
                cout << "efhh";
                for (int j = i; j < n / 4 - 1; ++j) cout << "....";
                cout << ".";
            } for (int j = 0; j < n - 5; ++j) cout << ".";
            cout << "aabcc\n";
            for (int j = 0; j < n - 5; ++j) cout << ".";
            cout << "ddb.e\n";
            for (int j = 0; j < n - 5; ++j) cout << ".";
            cout << "ffgge\n";
            for (int j = 0; j < n - 5; ++j) cout << ".";
            cout << "..hij\n";
            for (int j = 0; j < n - 5; ++j) cout << ".";
            cout << "..hij\n";
        } else if (n % 4 == 2) {
            for (int i = 0; i < n / 4 - 1; ++i, cout << '\n') {
                for (int j = 0; j < i; ++j) cout << "....";
                cout << "aabc";
                for (int j = i; j < n / 4 - 1; ++j) cout << "....";
                cout << "..";
                cout << '\n';
                for (int j = 0; j < i; ++j) cout << "....";
                cout << "ddbc";
                for (int j = i; j < n / 4 - 1; ++j) cout << "....";
                cout << "..";
                cout << '\n';
                for (int j = 0; j < i; ++j) cout << "....";
                cout << "efgg";
                for (int j = i; j < n / 4 - 1; ++j) cout << "....";
                cout << "..";
                cout << '\n';
                for (int j = 0; j < i; ++j) cout << "....";
                cout << "efhh";
                for (int j = i; j < n / 4 - 1; ++j) cout << "....";
                cout << "..";
            } for (int j = 0; j < n - 6; ++j) cout << ".";
            cout << "ab.c..\n";
            for (int j = 0; j < n - 6; ++j) cout << ".";
            cout << "ab.c..\n";
            for (int j = 0; j < n - 6; ++j) cout << ".";
            cout << "d.e.ff\n";
            for (int j = 0; j < n - 6; ++j) cout << ".";
            cout << "d.eg..\n";
            for (int j = 0; j < n - 6; ++j) cout << ".";
            cout << ".hhgii\n";
            for (int j = 0; j < n - 6; ++j) cout << ".";
            cout << "jjkkll\n";
        } else {
            for (int i = 0; i < n / 4 - 1; ++i, cout << '\n') {
                for (int j = 0; j < i; ++j) cout << "....";
                cout << "aabc";
                for (int j = i; j < n / 4 - 1; ++j) cout << "....";
                cout << "...";
                cout << '\n';
                for (int j = 0; j < i; ++j) cout << "....";
                cout << "ddbc";
                for (int j = i; j < n / 4 - 1; ++j) cout << "....";
                cout << "...";
                cout << '\n';
                for (int j = 0; j < i; ++j) cout << "....";
                cout << "efgg";
                for (int j = i; j < n / 4 - 1; ++j) cout << "....";
                cout << "...";
                cout << '\n';
                for (int j = 0; j < i; ++j) cout << "....";
                cout << "efhh";
                for (int j = i; j < n / 4 - 1; ++j) cout << "....";
                cout << "...";
            } for (int j = 0; j < n - 7; ++j) cout << ".";
            cout << "a.bbcc.\n";
            for (int j = 0; j < n - 7; ++j) cout << ".";
            cout << "add...e\n";
            for (int j = 0; j < n - 7; ++j) cout << ".";
            cout << "..f.gge\n";
            for (int j = 0; j < n - 7; ++j) cout << ".";
            cout << "hhf...i\n";
            for (int j = 0; j < n - 7; ++j) cout << ".";
            cout << ".j.k..i\n";
            for (int j = 0; j < n - 7; ++j) cout << ".";
            cout << "lj.k...\n";
            for (int j = 0; j < n - 7; ++j) cout << ".";
            cout << "l..mmnn\n";
        }
    }
}

} // namespace lowspeed_song

P17781 千早爱音不是罪过题解

Mon, 02 Nov 2026 07:25:00 GMT

来复读一下第一篇题解。

直接枚举所有排列显然你是不可行的，因此考虑枚举哪些边紧密相连。钦定若干条边相邻是简单的，因此考虑子集反演，给每条边染成黑 / 白 / 灰三种颜色，其中黑边要求强制相邻并保留在最终的连通块中，白边要求强制相邻且不保留到最终连通块中（贡献为 −1-1−1），灰边不做额外的限制。考虑这个为什么是对的。固定一个排列，设真正相邻的树边集合为 EEE，则若最终选定的黑边集合 B⊆EB\subseteq EB⊆E 则其余实际相邻的边可以染白色也可以染灰色，这些选择的容斥系数恰好当且仅当黑边恰好为真正相邻的边时才会留下贡献，因此只需要枚举黑白灰三种边并计算其带容斥系数后的贡献即可。

然后容易发现每个点最多向子树内连一条非灰的边。因此所有染色边一定是形成了若干条从上到下的链。套路的把每个染色链都缩成一个点，此时只需要计算缩点后的有根树的拓扑序数量，这个部分可以直接树上背包解决。设当前已经处理的 uuu 部分缩点后有 iii 个点，儿子结点 vvv 为根的子树中缩点后有 jjj 个点，则需要分类讨论：

若 u,vu,vu,v 两点间的边染成灰色，则两个部分独立，合并后的排列数量需要乘 (i+j−1j)\binom{i+j-1}j(ji+j−1)。
否则，两个部分的链首尾拼接，合并后的排列数量需要乘以 (i+j−2j−1){\binom{i+j-2}{j-1}}(j−1i+j−2)。

然后这个东西可以直接 O(n2)O(n^2)O(n2) 求出来。设当前已经处理了一部分树的信息，且此时黑边形成若干个连通块，则显然要合并一个儿子结点，若连儿子的边不是黑边，则两个部分的连通块互不影响，权值直接相乘即可。而若连儿子的边是黑边，则两个部分分别有一个连通块需要合并，其权值需要先异或起来再和其他部分拼接相乘。因此可以想到把包含当前根结点 uuu 的黑色连通块留起来先暂时不计算，其他连通块的权值先全都乘起来。然后把包含 uuu 的黑色连通块的权值异或和，其他所有黑色连通块的权值的乘积以及对应的拓扑序数量和白边的容斥系数相乘就可以得到答案。

直接把异或和这个维度记到状态中肯定爆炸了，套路的考虑拆位，每次只在 dp 中记录一个位的异或即可。具体的转移不是重点而且写起来特别累所以这里就不写具体转移了。算法的时间复杂度为 O(n2log⁡V)O(n^2\log V)O(n2logV) 可以通过该题。

新的一篇

Mon, 02 Nov 2026 04:00:00 GMT

从这里开始

写下你的想法。右侧是博客实际的排版，手机上可以切换到预览。

打开「语法手册」，试试提醒块、标签卡、公式和更多 Shoka 语法。

Records

Mon, 02 Nov 2026 03:26:00 GMT

test

P17802 [CXOI2026] 想要变成鹰的鱼题解

Wed, 28 Oct 2026 01:14:10 GMT

题目名居然过审了，好神奇

Fibonacci 数列有经典结论 gcd⁡(fa,fb)=fgcd⁡(a,b)\gcd(f_a,f_b)=f_{\gcd(a,b)}gcd(fa,fb)=fgcd(a,b)，因此考虑 gcd-lcm 反演，lcm⁡(fa1,fa2,…,fan)=∏∅≠I⊆{1,2,3,…,n}(gcd⁡i∈Ifai)(−1)∣I∣+1=∏∅≠I⊆{1,2,3,…,n}fgcd⁡i∈Iai(−1)∣I∣+1\operatorname{lcm}(f_{a_1},f_{a_2},\ldots,f_{a_n})=\prod\limits_{\varnothing\neq I\subseteq\lbrace 1,2,3,\ldots,n\rbrace}(\gcd\limits_{i\in I}f_{a_i})^{(-1)^{|I|+1}}=\prod\limits_{\varnothing\neq I\subseteq\lbrace 1,2,3,\ldots,n\rbrace}f_{\gcd\limits_{i\in I}a_i}^{(-1)^{|I|+1}}lcm(fa1,fa2,…,fan)=∅=I⊆{1,2,3,…,n}∏(i∈Igcdfai)(−1)∣I∣+1=∅=I⊆{1,2,3,…,n}∏fi∈Igcdai(−1)∣I∣+1。然后再对指数部分做反演，定义 gd=∏e∣dfeμ(d/e)g_d=\prod\limits_{e\mid d}f_e^{\mu(d/e)}gd=e∣d∏feμ(d/e) 则有 fi=∏d∣igdf_i=\prod\limits_{d\mid i}g_dfi=d∣i∏gd，代入上面反演的式子可得 lcm⁡(fa1,fa2,…,fan)=∏∅≠I⊆{1,2,3,…,n}(∏d∣(gcd⁡j∈Iaj)gd)(−1)∣I∣+1=∏∅≠I⊆{1,2,3,…,n}(∏d∣(gcd⁡j∈Iaj)gd(−1)∣I∣+1)=∏d≥1gd∑∅≠I⊆{1,2,3,…,n},d∣(gcd⁡j∈Iaj)(−1)∣I∣+1\operatorname{lcm}(f_{a_1},f_{a_2},\ldots,f_{a_n})=\prod\limits_{\varnothing\neq I\subseteq\lbrace1,2,3,\ldots,n\rbrace}(\prod\limits_{d\mid (\gcd\limits_{j\in I}a_j)}g_d)^{(-1)^{|I|+1}}=\prod\limits_{\varnothing\neq I\subseteq\lbrace1,2,3,\ldots,n\rbrace}(\prod\limits_{d\mid(\gcd\limits_{j\in I}a_j)}g_d^{(-1)^{|I|+1}})=\prod\limits_{d\ge 1}g_d^{\sum\limits_{\varnothing\neq I\subseteq\lbrace1,2,3,\ldots,n\rbrace,d\mid(\gcd\limits_{j\in I}a_j)}(-1)^{|I|+1}}lcm(fa1,fa2,…,fan)=∅=I⊆{1,2,3,…,n}∏(d∣(j∈Igcdaj)∏gd)(−1)∣I∣+1=∅=I⊆{1,2,3,…,n}∏(d∣(j∈Igcdaj)∏gd(−1)∣I∣+1)=d≥1∏gd∅=I⊆{1,2,3,…,n},d∣(j∈Igcdaj)∑(−1)∣I∣+1。为了方便，后面记指数部分 Ed=∑∅≠I⊆{1,2,3,…,n},d∣(gcd⁡j∈Iaj)(−1)∣I∣+1=∑∅≠I⊆{1,2,3,…,n},d∣ai,∀i∈I(−1)∣I∣+1E_d=\sum\limits_{\varnothing\neq I\subseteq\lbrace1,2,3,\ldots,n\rbrace,d\mid(\gcd\limits_{j\in I}a_j)}(-1)^{|I|+1}=\sum\limits_{\varnothing\neq I\subseteq\lbrace1,2,3,\ldots,n\rbrace,d\mid a_i,\forall i\in I}(-1)^{|I|+1}Ed=∅=I⊆{1,2,3,…,n},d∣(j∈Igcdaj)∑(−1)∣I∣+1=∅=I⊆{1,2,3,…,n},d∣ai,∀i∈I∑(−1)∣I∣+1。

记 Sd={i:d∣ai}S_d=\lbrace i:d\mid a_i\rbraceSd={i:d∣ai}，则有 Ed=∑∅≠I⊆Sd(−1)∣I∣+1E_d=\sum\limits_{\varnothing\neq I\subseteq S_d}(-1)^{|I|+1}Ed=∅=I⊆Sd∑(−1)∣I∣+1。容易发现如果 Sd=∅S_d=\varnothingSd=∅ 则 Ed=0E_d=0Ed=0，否则有 Ed=1E_d=1Ed=1。因此最终可以得到 lcm⁡(fa1,fa2,…,fan)=∏d≥1,∃i,d∣aigd\operatorname{lcm}(f_{a_1},f_{a_2},\ldots,f_{a_n})=\prod\limits_{d\ge 1,\exists i,d\mid a_i}g_dlcm(fa1,fa2,…,fan)=d≥1,∃i,d∣ai∏gd。记 D=⋃i=1n{d:d∣ai}D=\bigcup\limits_{i=1}^n\lbrace d:d\mid a_i\rbraceD=i=1⋃n{d:d∣ai} 则上面的式子又可以被简记为 ∏d∈Dgd\prod\limits_{d\in D}g_dd∈D∏gd 的形式。

然后考虑如何求出所有前缀的答案。记 Di=⋃j=1i{d:d∣aj}D_i=\bigcup\limits_{j=1}^i\lbrace d:d\mid a_j\rbraceDi=j=1⋃i{d:d∣aj}，则根据上面的结论可以得到 Li=lcm⁡(fa1,fa2,…,fai)=∏d∈DigdL_i=\operatorname{lcm}(f_{a_1},f_{a_2},\ldots,f_{a_i})=\prod\limits_{d\in D_i}g_dLi=lcm(fa1,fa2,…,fai)=d∈Di∏gd。注意到 DiD_iDi 随着 iii 的增加只会加入新的元素，因此考虑记录每个约数 ddd 第一次出现的位置 td=min⁡{i:d∣ai}t_d=\min\lbrace i:d\mid a_i\rbracetd=min{i:d∣ai}，则有 Li=Li−1∏td=igdL_i=L_{i-1}\prod\limits_{t_d=i}g_dLi=Li−1td=i∏gd，其中 L0=1L_0=1L0=1。因此问题被转化为预处理所有的 gdg_dgd，然后按照第一次出现的位置进行累乘。

接下来考虑如何快速计算 gdg_dgd。根据前面的定义有 gd=∏e∣dfeμ(d/e)g_d=\prod\limits_{e\mid d}f_e^{\mu(d/e)}gd=e∣d∏feμ(d/e)，注意到 DDD 集合对取约数是封闭的，因此考虑直接在乘法意义下进行莫比乌斯反演。先初始化所有 gd=fdg_d=f_dgd=fd，然后对所有在 DDD 中出现过的质数 ppp 执行 gd←gd/gd/pg_d\leftarrow g_d/g_{d/p}gd←gd/gd/p（p∣dp\mid dp∣d），对同一个质数 ppp 按照 vp(d)v_p(d)vp(d) 的值从大到小处理，这样可以保证右侧的 gd/pg_{d/p}gd/p 还没有被当前质数对应的变换修改。这一步的正确性从 Mobius 函数的定义上就可以得到。下标很大的问题扔到哈希表中即可解决。

由于这里的除法需要在模 998244353998244353998244353 意义下进行，直接求逆元的时间复杂度有点小炸，因此考虑同时维护 hd=gd−1h_d=g_d^{-1}hd=gd−1，那么每次变换就相当于 gd←gdhd/p,hd←hdgd/pg_d\leftarrow g_dh_{d/p},h_d\leftarrow h_dg_{d/p}gd←gdhd/p,hd←hdgd/p，其中右侧均使用修改前的值。初始时 hd=fd−1h_d=f_d^{-1}hd=fd−1，这个东西可以利用前缀积和一次快速幂批量求逆，时间复杂度为 O(∣D∣+log⁡MOD)O(|D|+\log \text{MOD})O(∣D∣+logMOD)。由于每个 ddd 对每个不同质因子只需要处理一次，因此整个莫比乌斯反演的时间复杂度为 O(∑d∈Dω(d))O(\sum\limits_{d\in D}\omega(d))O(d∈D∑ω(d))。

然后考虑批量计算 x1<x2<…<xkx_1<x_2<\ldots<x_kx1<x2<…<xk 项的 Fibonacci 值，其中 x1,x2,…,xkx_1,x_2,\ldots,x_kx1,x2,…,xk 为 DDD 中的所有元素。这个东西考虑倍增求，设当前求出了 (fm,fm+1)=(a,b)(f_m,f_{m+1})=(a,b)(fm,fm+1)=(a,b) 则记 Δ=xi−m\Delta=x_i-mΔ=xi−m 倍增求出 (fΔ,fΔ+1)=(u,v)(f_{\Delta},f_{\Delta+1})=(u,v)(fΔ,fΔ+1)=(u,v)，然后根据 Fibonacci 序列的经典结论可知 fm+Δ=a(v−u)+bu,fm+Δ+1=au+bvf_{m+\Delta}=a(v-u)+bu,f_{m+\Delta+1}=au+bvfm+Δ=a(v−u)+bu,fm+Δ+1=au+bv，这样依次转移的时间复杂度为 O(log⁡(Δ+1))O(\log(\Delta+1))O(log(Δ+1))。因为所有下标的差值和不超过 A=max⁡aiA=\max a_iA=maxai，因此放缩一下可得 ∑i=1klog⁡(Δi+1)≤klog⁡(1+Ak)\sum\limits_{i=1}^k\log(\Delta_i+1)\le k\log(1+\frac Ak)i=1∑klog(Δi+1)≤klog(1+kA)，因此上面批量计算 kkk 个 Fibonacci 值的时间复杂度被优化到 O(klog⁡(1+Ak))O(k\log(1+\frac Ak))O(klog(1+kA))。对 xxx 数组排序用基数排序即可做到理论线性时间复杂度（不过我偷懒没写）。

最后考虑怎么算所有前缀的答案。前面已经预处理出了每个 d∈Dd\in Dd∈D 对应的 gdg_dgd 和第一次出现的位置 tdt_dtd，因此考虑按照 tdt_dtd 的值分类计算，记 Bi=∏td=igdB_i=\prod\limits_{t_d=i}g_dBi=td=i∏gd，则 Li=∏j=1iBjL_i=\prod\limits_{j=1}^iB_jLi=j=1∏iBj。这个东西只需要按照 iii 从小到大扫描然后维护前缀乘积即可，时间复杂度为 O(∣D∣+n)O(|D|+n)O(∣D∣+n)。

然后有一个问题是模数 998244353998244353998244353 可能会整除某些 fxf_xfx。打表可得最小的满足 fx≡0(mod998244353)f_x\equiv0\pmod{998244353}fx≡0(mod998244353) 的正整数 xxx 为 499122177499122177499122177，然后根据 Fibonacci 序列的性质可知 fx≡0(mod998244353)f_x\equiv0\pmod{998244353}fx≡0(mod998244353) 当且仅当 499122177∣x499122177\mid x499122177∣x。因此只需要找到第一个满足 499122177∣ai499122177\mid a_i499122177∣ai 的位置，从这个位置开始所有前缀答案都为 000，只需要处理它之前的部分即可。这样也就保证了前面所有需要求逆的 Fibonacci 数都不为 000。

代码实现偷懒写了 __gnu_pbds::gp_hash_table，如果手写哈希表的话应该会跑的更快一些（）

namespace lowspeed_song {

mt19937_64 mt(time(0));

inline pair<int, int> fibonacci(int n) {
    if (!n) return {0, 1};
    i64 a = 0, b = 1;
    for (int i = 31 - __builtin_clz(n); ~i; --i) {
        i64 c = a * ((2 * b - a + mod) % mod) % mod, d = (a * a + b * b) % mod;
        if (n >> i & 1) a = d, b = (c + d) % mod;
        else a = c, b = d;
    } return {a, b};
}

struct myhash {
    inline size_t operator()(u64 x) const {
        return splitmix64(x);
    }
};

vector<int> dv, fir;
__gnu_pbds::gp_hash_table<int, int, myhash> id;
unordered_map<int, vector<u32>> buc;

int e[N];
vector<pair<int, int>> fac;

int pos;

inline void dfs(int dep, int d) {
    if (dep == fac.size()) {
        if (!id.insert({d, (int)dv.size()}).second) return;
        int t = dv.size(); dv.emplace_back(d), fir.emplace_back(pos);
        for (int i = 0; i < fac.size(); ++i) if (e[i])
            buc[fac[i].first].emplace_back((u32(t) << 5) | e[i]);
        return;
    } int pwr = 1;
    for (int i = 0; i <= fac[dep].second; ++i) {
        e[dep] = i, dfs(dep + 1, d * pwr);
        if (i < fac[dep].second) pwr *= fac[dep].first;
    }
}

int isp[N], pr[N], idx;

inline void init() {
    isp[1] = 1;
    for (int i = 2; i < 200010; ++i) {
        if (!isp[i]) pr[++idx] = i;
        for (int j = 1; j <= idx && i * pr[j] < 200010; ++j) {
            isp[i * pr[j]] = 1;
            if (i % pr[j] == 0) break;
        }
    }
}

vector<int> bc[32];
int a[N], f[N], g[N], pre[N], inv[N];

inline void sol([[maybe_unused]]int __testcase_id, [[maybe_unused]]int __testcase_sum) {
    int n; cin >> n;
    for (int i = 1; i <= n; ++i) cin >> a[i];
    int lasp = n; for (int i = 1; i <= n; ++i)
        if (a[i] % 499122177 == 0) { lasp = i - 1; break; }
    if (!lasp) {
        for (int i = 0 ;i < n; ++i) cout << 0 << ' ';
        cout << '\n';
    } else {
        for (int i = 1; i <= lasp; ++i) {
            if (id.find(a[i]) != id.end()) continue;
            fac.clear(), pos = i;
            int tmp = a[i];
            for (int j = 1; j <= idx && pr[j] * pr[j] <= tmp; ++j) if (tmp % pr[j] == 0) {
                int cnt = 0;
                while (tmp % pr[j] == 0) tmp /= pr[j], ++cnt;
                fac.emplace_back(pr[j], cnt);
            } if (tmp > 1) fac.emplace_back(tmp, 1);
            for (int i = 0; i <= fac.size(); ++i) e[i] = 0;
            dfs(0, 1);
        } vector<int> ord(dv.size(), 0);
        ranges::iota(ord, 0), ranges::sort(ord, [&](auto &l, auto &r) {
            return dv[l] < dv[r];
        });
        int las = 0, f0 = 0, f1 = 1;
        pre[0] = 1;
        for (int i = 0; i < dv.size(); ++i) {
            auto [u, v] = fibonacci(dv[ord[i]] - las);
            int nf0 = (1ll * f0 * (v - u + mod) + 1ll * f1 * u) % mod;
            int nf1 = (1ll * f0 * u + 1ll * f1 * v) % mod;
            f0 = nf0, f1 = nf1, las = dv[ord[i]], g[ord[i]] = f0;
            pre[i + 1] = 1ll * pre[i] * f0 % mod;
        } int I = inversion(pre[dv.size()]);
        for (int i = (int)dv.size() - 1; ~i; --i) {
            inv[ord[i]] = 1ll * pre[i] * I % mod;
            I = 1ll * I * g[ord[i]] % mod;
        } vector<int>().swap(ord);
        for (auto &[p, v] : buc) {
            int lim = 0;
            for (u32 &o : v) lim = max<int>(lim, o & 31);
            for (int i = 0; i <= lim; ++i) bc[i].clear();
            for (u32 &o : v) bc[o & 31].emplace_back(o >> 5);
            for (int i = lim; i; --i) for (int j : bc[i]) {
                int k = id.find(dv[j] / p)->second;
                g[j] = 1ll * g[j] * inv[k] % mod, inv[j] = 1ll * inv[j] * g[k] % mod;
            }
        } for (int i = 0; i <= n; ++i) f[i] = 1;
        for (int i = 0; i < dv.size(); ++i) f[fir[i]] = 1ll * f[fir[i]] * g[i] % mod;
        int res = 1; for (int i = 1; i <= n; ++i) {
            if (i > lasp) res = 0;
            else res = 1ll * res * f[i] % mod;
            cout << res << ' ';
        } cout << '\n';
    }
}

} // namespace lowspeed_song

P17801 [CXOI2026] 大潘小潘向前 p 题解

Mon, 26 Oct 2026 03:17:51 GMT

首先问题可以被转化为计数长度为 nnn 的整数序列 aaa 满足下面两个条件：

1≤ai≤bi1\le a_i\le b_i1≤ai≤bi（bib_ibi 是所有对序列限制的上界）
序列恰好有 k−1k-1k−1 个位置 iii 满足 ai>ai+1a_i>a_{i+1}ai>ai+1。

考虑 dp。设 fi,jf_{i,j}fi,j 表示当前考虑了前 iii 个位置，被切成了 jjj 个连续不下降段，且 iii 位置为第 jjj 个连续段的最后一个位置的方案数。初始条件显然就是 f0,0=1f_{0,0}=1f0,0=1。转移考虑枚举第 jjj 个连续不下降段是 [p,i][p,i][p,i]，则转移方程可以写作 fi,j=∑p=1ifp−1,j−1gp,if_{i,j}=\sum\limits_{p=1}^if_{p-1,j-1}g_{p,i}fi,j=p=1∑ifp−1,j−1gp,i，其中 gp,ig_{p,i}gp,i 是 [p,i][p,i][p,i] 区间形成不同的不下降段的数量。

现在考虑计算 gi,jg_{i,j}gi,j 的值。注意到此时满足条件的序列 aaa 必须满足 ai≤ai+1≤…≤aja_i\le a_{i+1}\le\ldots\le a_jai≤ai+1≤…≤aj，因此考虑先收紧上界，记 ck=min⁡p=kjbpc_k=\min\limits_{p=k}^jb_pck=p=kminjbp（即区间的后缀上界最小值），则上界限制可以变为 1≤ak≤ck1\le a_k\le c_k1≤ak≤ck，并且有 ci≤ci+1≤…≤cjc_i\le c_{i+1}\le\ldots\le c_jci≤ci+1≤…≤cj。

规定空区间的方案数为 gj+1,j=1g_{j+1,j}=1gj+1,j=1，则可以得到递推式 gi,j=∑t=1j−i+1(−1)t−1(cit)gi+t,jg_{i,j}=\sum\limits_{t=1}^{j-i+1}(-1)^{t-1}\binom{c_i}{t}g_{i+t,j}gi,j=t=1∑j−i+1(−1)t−1(tci)gi+t,j。计算时固定右端点 jjj，按照 i=j,j−1,…,1i=j,j-1,\ldots,1i=j,j−1,…,1 的顺序转移即可。由于组合数的下标 ttt 不超过 nnn，可以利用 (xt)=(xt−1)x−t+1t\binom{x}{t}=\binom{x}{t-1}\frac{x-t+1}{t}(tx)=(t−1x)tx−t+1 依次计算，不需要预处理到 VVV。

但是注意到上面 fff 的 dp 计算的是将序列切成 jjj 个不下降段的方案数，并不等于恰好有 j−1j-1j−1 个位置满足 ai>ai+1a_i>a_{i+1}ai>ai+1 的序列数量。设 AkA_kAk 表示恰好有 k−1k-1k−1 个下降位置的序列数量。对于这样的序列，所有下降位置都必须切开，然后还要从剩下的 n−kn-kn−k 个位置中选择 j−kj-kj−k 个位置切开，因此有 fn,j=∑k=1jAk(n−kj−k)f_{n,j}=\sum\limits_{k=1}^jA_k\binom{n-k}{j-k}fn,j=k=1∑jAk(j−kn−k)。从小到大计算即可得到 Ak=fn,k−∑j=1k−1Aj(n−jk−j)A_k=f_{n,k}-\sum\limits_{j=1}^{k-1}A_j\binom{n-j}{k-j}Ak=fn,k−j=1∑k−1Aj(k−jn−j)。

计算所有 gi,jg_{i,j}gi,j 和 fi,jf_{i,j}fi,j 的时间复杂度均为 O(n3)O(n^3)O(n3)，最后反演的时间复杂度为 O(n2)O(n^2)O(n2)，因此整个算法的时间复杂度就是 O(n3)O(n^3)O(n3)，可以通过该题。

:::success[代码实现]


namespace lowspeed_song {

int C[1010][1010], inv[N];

inline void init() {
    C[0][0] = 1;
    for (int i = 1; i < 1010; ++i) {
        C[i][0] = 1;
        for (int j = 1; j <= i; ++j)
            C[i][j] = (C[i - 1][j - 1] + C[i - 1][j]) % mod;
    }
    inv[0] = inv[1] = 1;
    for (int i = 2; i < N; ++i) inv[i] = mod - inv[mod % i] * (mod / i) % mod;
}

int x[N], y[N], b[N], f[510][510], g[510][510], res[N];

inline void sol() {
    int n, m, V; cin >> n >> m >> V;
    for (int i = 1; i <= m; ++i) cin >> x[i] >> y[i];
    for (int i = 1; i <= n; i++) b[i] = V;
    for (int i = 1; i <= m; ++i) b[x[i]] = min(b[x[i]], y[i]);
    memset(f, 0, sizeof f), memset(g, 0, sizeof g);
    for (int i = 1; i <= n; ++i) {
        g[i + 1][i] = 1;
        int mi = V;
        for (int j = i; j; --j) {
            mi = min(mi, b[j]);
            int s = 0, c = 1;
            for (int k = 1; k <= min(mi, i - j + 1); ++k) {
                c = c * (mi - k + 1) % mod * inv[k] % mod;
                if (k & 1) s = (s + c * g[j + k][i] % mod) % mod;
                else s = (s + mod - c * g[j + k][i] % mod) % mod;
            } g[j][i] = s;
        }
    } f[0][0] = 1;
    for (int i = 1; i <= n; ++i)
        for (int j = 1; j <= i; ++j)
            for (int k = j; k <= i; ++k) f[i][j] = (f[i][j] + f[k - 1][j - 1] * g[k][i] % mod) % mod;
    for (int i = 1; i <= n; ++i) {
        res[i] = f[n][i];
        for (int j = 1; j < i; ++j) res[i] = (res[i] + mod - C[n - j][i - j] * res[j] % mod) % mod;
        cout << res[i] << ' ';
    } cout << '\n';
}

} // namespace lowspeed_song
:::

P17800 [CXOI R7-D] 使一颗心不免哀伤题解

Sun, 25 Oct 2026 13:37:20 GMT

Official Solution.

sol 1

sol: Lemansky

Time：2024/05

首先看到 XOR 构造容易想到一个经典的套路：2k⊕(2k+1)=12k\oplus(2k+1)=12k⊕(2k+1)=1（partner），不妨把这样的组合称为 P。

先考虑无解的情况，显然 xxx 的最高位不能超过 nnn，否则无解。

nnn 为 222 的幂可以发现二进制下第 kkk 位只有 nnn 是 111 不能消去，所以 x<nx<nx<n 无解。

n≤3n\le 3n≤3 进行特判，除 n=2,x=3n=2,x=3n=2,x=3 和 n=3,x=0n=3,x=0n=3,x=0 外无解，有解的构造都是链。

接下来考虑 nnn 为奇数且 x<nx<nx<n，也就是说 2∼n2\sim n2∼n 每个数都能和 partner 配对使得异或完为 111。于是我们只需要以 111 为根，xxx 和 x⊕1x\oplus 1x⊕1 作为 111 的子，P 作为 xxx 的子即可。此时 n≥5,x≥2n\ge 5,x\ge 2n≥5,x≥2 均有解。

x=0x=0x=0 时直接 111 接 P，x=1x=1x=1 时找一对 P 顶替 111 的位置即可。

nnn 为偶数且 x=nx=nx=n 也可以这么做，此时不管 n⊕1n\oplus 1n⊕1。

当 nnn 为奇数且 x>nx>nx>n，由于有解，所以 xxx 和 nnn 最高位相同，那么显然有 x⊕n<nx\oplus n<nx⊕n<n，此时我们取 n⊕[x⊕n]=xn\oplus[x\oplus n]=xn⊕[x⊕n]=x，包含其 partner 共四个数： n,n−1,x⊕n,x⊕(n−1)n,n-1,x\oplus n,x\oplus (n-1)n,n−1,x⊕n,x⊕(n−1)。它们可以使用，且两两组合可以得到 xxx，于是参照上面做法，根下面拆成两部分接 P 即可。此时 n≥9n\ge 9n≥9 均有解。

n=5n=5n=5 特判，交换组合得到 x⊕1x\oplus 1x⊕1，不接 P 即可。

n=7n=7n=7 不会出现此情况。

接下来考虑 nnn 为偶数，设问题为 T(n,x)T(n,x)T(n,x)，考虑将 nnn 作为根，其子树变为 T(n,x)T(n,x)T(n,x) 的子问题 T′(n−1,x⊕n)T'(n-1,x\oplus n)T′(n−1,x⊕n)，也就是构造若干棵树，根到叶子异或和都为 x⊕nx\oplus nx⊕n，直接使用上面的构造即可。此时 n≥6n\ge 6n≥6 均有解。

n=4n=4n=4 特判，构造是简单的。

:::success[代码实现]

#include<bits/stdc++.h>
using namespace std;
int T,n,x;
void cal(int n,int x){
	if(x<=n){
		for(int i=2;i<=n;i++){
		    if(i==x||i==(x^1))cout<<1<<' ';
		    else if(i&1)cout<<(i^1)<<' ';
		    else if(x==0)cout<<1<<' ';
		    else if(x==1)cout<<(i==2?1:3)<<' ';
		    else cout<<x<<' ';
		}
	}
	else{
        int d=0;
		for(int i=2;i<=n;i++){
		    if(i==(n^x)||i==(n^x^1))cout<<(i^x^(n==5))<<' ';
		    else if(i==(n^1))cout<<1<<' ';
		    else if(i==n)cout<<1<<' ';
		    else if(i&1)cout<<(i^1)<<' ';
		    else cout<<(n^x^(d>0))<<' ',++d;
		}
	}
}
int main(){
    cin>>T;
    while(T--){
        cin>>n>>x;
        if(n==2&&x==3)cout<<"Yes\n0 1";
        else if(n==3&&x==0)cout<<"Yes\n0 1 2";
        else if(n==4&&x==5)cout<<"Yes\n4 4 2 0";
        else if(n==4&&x==6)cout<<"Yes\n4 4 1 0";
        else if(n==4&&x==7)cout<<"Yes\n4 1 4 0";
        else if(n<=3||((1<<__lg(n))==n&&x<n)||__lg(x)>__lg(n))cout<<"No";
        else if((n&1)||x==n)cout<<"Yes\n"<<0<<' ',cal(n,x);
        else cout<<"Yes\n"<<n<<' ',cal(n-1,x^n),cout<<0<<' ';
        cout<<'\n';
    }
    return 0;
}

:::

sol 2

sol: Priestess_SLG

Time：2026/02/13

n≤10n\le 10n≤10

直接暴力枚举出所有的 prufer 序列，将序列转化为树然后判断是否合法即可。（当然更简单的方法是直接枚举每个结点的父结点）。

n≤2000n\le 2000n≤2000

给一些时间复杂度写假了的做法留的。

一些简单的无解情况

记 high(n)=2⌊log⁡2n⌋high(n)=2^{\lfloor\log_2n\rfloor}high(n)=2⌊log2n⌋，即 high(n)high(n)high(n) 为不超过 nnn 的最大 222 的整数次幂。很显然 1∼n1\sim n1∼n 的点的编号异或起来得到的结果一定小于 2high(n)2high(n)2high(n)。因此若有 x≥2high(n)x\ge 2high(n)x≥2high(n) 则无解。

n≤6n\le 6n≤6

边界情况，在正解中必须单独讨论处理，套用之前 n≤10n\le 10n≤10 的暴力做法，或手动打表处理均可。

2∤n2\nmid n2∤n 且 x=0x=0x=0

考虑异或的经典性质：2k⊕(2k+1)=12k\oplus(2k+1)=12k⊕(2k+1)=1。因此容易想到以 111 号结点为根，然后对于任意正整数 kkk 满足 2k+1≤n2k+1\le n2k+1≤n，在树上添加一条 1→2k→2k+11\to 2k\to 2k+11→2k→2k+1 的链即可。

此时 3,5,7,9,…,n3,5,7,9,\ldots,n3,5,7,9,…,n 号结点为叶子结点。容易证明此时上述所有结点到根节点的简单路径上结点编号的异或值都为 000，符合构造条件。

2∣n2\mid n2∣n 且 x=nx=nx=n

令根结点为 nnn，然后在 nnn 的子树中操作，此时剩下编号为 1∼n−11\sim n-11∼n−1 的结点，在这些结点中只需要满足所有叶子结点到该子树内根结点的路径上所有结点编号的异或值为 000 即可，转化为 2∤n2\nmid n2∤n 且 x=0x=0x=0 的情况讨论即可。

2∤n2\nmid n2∤n 且 x=1x=1x=1

注意到 1⊕2⊕3=01\oplus 2\oplus 3=01⊕2⊕3=0，因此考虑到以 111 号节点为根结点，然后连一条 1→2→31\to 2\to 31→2→3 的链。而对于 333 号结点为根的子树，此时只需要使得每个叶子结点到 333 号结点的路径上所有结点编号的异或值为 3⊕1=23\oplus 1=23⊕1=2 即可。容易想到对于每个正整数 kkk 满足 k>1k>1k>1 且 2k+1≤n2k+1\le n2k+1≤n，都构造一条 3→2k→2k+13\to 2k\to 2k+13→2k→2k+1 的链即可满足条件。

2∣n2\mid n2∣n 且 x=n+1x=n+1x=n+1

同样的，考虑以 nnn 为根，然后问题转化为 2∤n−12\nmid n-12∤n−1 且 x=1x=1x=1 的情况，对剩下的 n−1n-1n−1 个点做上面提到的构造即可。

n=2k,k∈N+n=2^k,k\in\mathbb{N_+}n=2k,k∈N+

注意到此时二进制表示中 2k2^k2k 位只有 nnn 一个数为 111，因此任何一条经过 nnn 号结点的路径，其结点编号异或值必然 ≥n\ge n≥n。

因此 x<nx<nx<n 时无解。

而在 x≥nx\ge nx≥n 时，因为 2∣2k2\mid 2^k2∣2k，所以再按照 2∣n2\mid n2∣n 的构造方案构造即可。

2∣n2\mid n2∣n

同样的，把根节点设为 nnn 号结点，然后在 nnn 号结点的子树内构造答案，此时问题转化为 2∤n2\nmid n2∤n 的情况，只需要让 x←x⊕n,n←n−1x\leftarrow x\oplus n,n\leftarrow n-1x←x⊕n,n←n−1 即可。

2∤n2\nmid n2∤n 且 x≤nx\le nx≤n

x∈{0,1}x\in\lbrace 0,1\rbracex∈{0,1} 的情况上面都已经单独讨论过了，因此此时只需要处理 2≤x≤n2\le x\le n2≤x≤n 的情况即可。

此时考虑一个简单通用的构造方案：令 111 号结点为根结点，然后让 111 号结点的两个儿子结点分别为 xxx 号结点和 x⊕1x\oplus 1x⊕1 号结点。而此时对于所有剩下的 (2k,2k+1)(2k,2k+1)(2k,2k+1) 结点组，构造链 x→2k→2k+1x\to 2k\to 2k+1x→2k→2k+1 即可满足条件。

2∤n2\nmid n2∤n 且 n<x<2high(n)n<x<2high(n)n<x<2high(n)

构造的思路和上一类情况是类似的，但是会稍微复杂一些。

记 p=high(n)⊕xp=high(n)\oplus xp=high(n)⊕x。此时从所有的 (2k,2k+1)(2k,2k+1)(2k,2k+1) 结点组里找出一组，使得所有结点组中不存在结点 high(n),high(n)⊕1,p,p⊕1high(n),high(n)\oplus 1,p,p\oplus 1high(n),high(n)⊕1,p,p⊕1 即可。容易证明此时因为 n>6n>6n>6，所以根据鸽巢原理，必然可以找到一个这样的结点组。下面记这个结点对是 (2u,2u+1)(2u,2u+1)(2u,2u+1)。

那么考虑下面的构造：先构造一条链 1→2u→2u+1→p⊕1→high(n)1\to 2u\to 2u+1\to p\oplus 1\to high(n)1→2u→2u+1→p⊕1→high(n)。此时有 1∼high(n)1\sim high(n)1∼high(n) 这条路径上所有结点编号异或值为 x⊕1x\oplus 1x⊕1。此时在这条路径上再插入二元组 (2k,2k+1)(2k,2k+1)(2k,2k+1)，得到形如 1→2u→2u+1→p⊕1→high(n)→2k→2k+11\to 2u\to 2u+1\to p\oplus 1\to high(n)\to 2k\to 2k+11→2u→2u+1→p⊕1→high(n)→2k→2k+1 的链，就可以满足所有叶子结点 2k+12k+12k+1 到根结点 111 的路径上所有结点编号的异或值都为 xxx。

此时剩下结点 p,high(n)⊕1p,high(n)\oplus1p,high(n)⊕1 没有被加入树中。注意到 1⊕p⊕(high(n)⊕1)=x1\oplus p\oplus (high(n)\oplus1)=x1⊕p⊕(high(n)⊕1)=x，因此在树上再插入一条 1→p→high(n)⊕11\to p\to high(n)\oplus11→p→high(n)⊕1 的链即可完成构造。

时间复杂度

显然时间复杂度为 O(∑n)O(\sum n)O(∑n)，不过 O(∑nlog⁡n)O(\sum n\log n)O(∑nlogn) 的实现比较劣的写法也放过去了。

:::success[代码实现]

namespace Loyalty
{
    inline void init() {}
    int up[N];
    inline int high(int n) { return 1ll << (63 - __builtin_clzll(n)); }
    inline void main([[maybe_unused]] int _ca, [[maybe_unused]] int _atc)
    {
        int n, x;
        cin >> n >> x;
        if (x >= 2 * high(n))
            cout << "No\n";
        else
        {
            fill(up + 1, up + n + 1, 0);
            if (n <= 6)
            {
                if (n == 2)
                {
                    if (x < 3)
                        cout << "No\n";
                    else
                        cout << "Yes\n0 1\n";
                }
                else if (n == 3)
                {
                    if (x)
                        cout << "No\n";
                    else
                        cout << "Yes\n0 1 2\n";
                }
                else if (n == 4)
                {
                    if (x < 4)
                        cout << "No\n";
                    else if (x == 4)
                        cout << "Yes\n0 1 2 3\n";
                    else if (x == 5)
                        cout << "Yes\n4 4 2 0\n";
                    else if (x == 6)
                        cout << "Yes\n4 4 1 0\n";
                    else
                        cout << "Yes\n2 4 4 0\n";
                }
                else if (n == 5)
                {
                    if (!x)
                        cout << "Yes\n0 1 2 1 4\n";
                    else if (x == 1)
                        cout << "Yes\n0 1 2 3 4\n";
                    else if (x == 2)
                        cout << "Yes\n0 1 1 2 4\n";
                    else if (x == 3)
                        cout << "Yes\n0 1 1 3 4\n";
                    else if (x == 4)
                        cout << "Yes\n0 4 2 1 1\n";
                    else if (x == 5)
                        cout << "Yes\n0 5 2 1 1\n";
                    else if (x == 6)
                        cout << "Yes\n0 1 1 3 2\n";
                    else
                        cout << "Yes\n0 1 1 2 3\n";
                }
                else
                {
                    if (!x)
                        cout << "Yes\n6 1 1 3 2 0\n";
                    else if (x == 1)
                        cout << "Yes\n6 1 1 2 3 0\n";
                    else if (x == 2)
                        cout << "Yes\n6 4 2 1 1 0\n";
                    else if (x == 3)
                        cout << "Yes\n6 5 2 1 1 0\n";
                    else if (x == 4)
                        cout << "Yes\n6 1 1 2 4 0\n";
                    else if (x == 5)
                        cout << "Yes\n6 1 1 3 4 0\n";
                    else if (x == 6)
                        cout << "Yes\n6 1 2 1 4 0\n";
                    else
                        cout << "Yes\n6 1 2 3 4 0\n";
                }
            }
            else
            {
                if (n % 2 && !x)
                {
                    for (int k = 2; k <= n; k += 2)
                        up[k] = 1, up[k | 1] = k;
                }
                else if (n % 2 == 0 && x == n)
                {
                    up[1] = n;
                    for (int k = 2; k < n; k += 2)
                        up[k] = 1, up[k | 1] = k;
                }
                else if (n % 2 && x == 1)
                {
                    up[2] = 1, up[3] = 2;
                    for (int k = 4; k <= n; k += 2)
                        up[k] = 3, up[k | 1] = k;
                }
                else if (n % 2 == 0 && x == n + 1)
                {
                    up[1] = n, up[2] = 1, up[3] = 2;
                    for (int k = 4; k < n; k += 2)
                        up[k] = 3, up[k | 1] = k;
                }
                else if (n & 1)
                {
                    if (x <= n)
                    {
                        up[x] = 1, up[x ^ 1] = 1;
                        for (int k = 2; k < n; k += 2)
                            if (k != x && k != (x ^ 1))
                                up[k] = x, up[k | 1] = k;
                    }
                    else
                    {
                        int p = high(n) ^ x, u;
                        for (u = 2; u < n; u += 2)
                            if (u != p && u != (p ^ 1) && u != high(n) && u != (high(n) ^ 1))
                                break;
                        up[u] = 1, up[u | 1] = u, up[p ^ 1] = u | 1, up[high(n)] = p ^ 1;
                        for (int k = 2; k < n; k += 2)
                            if (k != p && k != (p ^ 1) && k != u && k != (u ^ 1) && k != high(n) && k != (high(n) ^ 1))
                                up[k] = high(n), up[k | 1] = k;
                        up[p] = 1, up[high(n) ^ 1] = p;
                    }
                }
                else
                {
                    if (!(n & (n - 1)) && x < n)
                    {
                        cout << "No\n";
                        return;
                    }
                    x ^= n;
                    // cerr << "up[n] = " << up[n] << '\n';
                    up[1] = n--;
                    if (x <= n)
                    {
                        up[x] = 1, up[x ^ 1] = 1;
                        for (int k = 2; k < n; k += 2)
                            if (k != x && k != (x ^ 1))
                                up[k] = x, up[k | 1] = k;
                    }
                    else
                    {
                        int p = high(n) ^ x, u;
                        for (u = 2; u < n; u += 2)
                            if (u != p && u != (p ^ 1) && u != high(n) && u != (high(n) ^ 1))
                                break;
                        up[u] = 1, up[u | 1] = u, up[p ^ 1] = u | 1, up[high(n)] = p ^ 1;
                        for (int k = 2; k < n; k += 2)
                            if (k != p && k != (p ^ 1) && k != u && k != (u ^ 1) && k != high(n) && k != (high(n) ^ 1))
                                up[k] = high(n), up[k | 1] = k;
                        up[p] = 1, up[high(n) ^ 1] = p;
                    }
                    ++n;
                }
                cout << "Yes\n";
                for_each(up + 1, up + n + 1, [&](auto &output) { cout << output << ' '; });
            }
        }
    }
} // namespace Loyalty

:::

Sol 3

sol: Bingxiu2, Lemansky

Time: 2026/10/21

构造

不妨先让我们构造出的答案最多只有两个叶子，此时树有且仅有一个分叉点，设从根到分叉点的公共前缀异或和为 AAA，两条分叉链的异或和都为 BBB，则每条根到叶子的路径异或和都是 A⊕BA\oplus BA⊕B。因此只需要构造出 A⊕B=xA\oplus B=xA⊕B=x。

记 S=1⊕2⊕⋯⊕nS=1\oplus2\oplus\cdots\oplus nS=1⊕2⊕⋯⊕n。由于所有点 A⊕B⊕B=SA\oplus B\oplus B=SA⊕B⊕B=S，因此 A=S,B=S⊕xA=S,B=S\oplus xA=S,B=S⊕x。

按 n mod 4n\bmod 4nmod4 初始化

容易发现 SSS 有周期规律如下：

n mod 4=0n\bmod4=0nmod4=0 时，S=nS=nS=n；
n mod 4=1n\bmod4=1nmod4=1 时，S=1S=1S=1；
n mod 4=2n\bmod4=2nmod4=2 时，S=n+1S=n+1S=n+1；
n mod 4=3n\bmod4=3nmod4=3 时，S=0S=0S=0。

于是根据 n mod 4n\bmod4nmod4 的取值，作如下讨论：

n mod 4n\bmod4nmod4	根	公共前缀	剩余点区间	BBB
000	nnn	nnn	[1,n−1][1,n-1][1,n−1]	x⊕nx\oplus nx⊕n
111	111	111	[2,n][2,n][2,n]	x⊕1x\oplus1x⊕1
222	nnn	n→1n\to1n→1	[2,n−1][2,n-1][2,n−1]	x⊕n⊕1x\oplus n\oplus1x⊕n⊕1
333	nnn	n→n−1→1n\to n-1\to1n→n−1→1	[2,n−2][2,n-2][2,n−2]	xxx

经过上述处理后，剩余点的总异或和都为 000。

二进制贪心分组

从大到小枚举剩余点 iii，维护两条链当前的末端 u,vu,vu,v。

如果 (B&i)=i(B\&i)=i(B&i)=i，说明 iii 的二进制位全部包含在当前 BBB 中，于是把 iii 接到第一组，并令 B←B⊕iB\leftarrow B\oplus iB←B⊕i。否则把 iii 接到第二组。

因为剩余点的总异或和为 000，所以如果第一组的异或和最终变为 BBB，那么第二组的异或和也必然是 BBB。于是满足要求。

CORNER CASE

当 n mod 4>0n\bmod4>0nmod4>0 时，剩余点从 222 开始，没有点 111 可用，如果贪心结束后还剩下 B=1B=1B=1，正常情况下无法直接消去。不过 n>3n>3n>3 时剩余点中一定包含 2,32,32,3，且 2⊕3=12\oplus3=12⊕3=1。所以可以把点 333 和点 222 改接到这条链上，使最后两条新链的异或和都为 111，从而补上这个 111。

若 n≤3n\le3n≤3，剩余点为空，无法修正，只能输出 No。

无解判定

完成贪心和特殊修正后，如果剩余 B=0B=0B=0，说明构造成功，输出 Yes；否则输出 No。

此时考虑我们构造不出的情况：

BBB 的最高位大于剩余点区间的右端点数的最高位，此时要么 xxx 的最高位大于 nnn 的最高位，要么 x<n=2kx<n=2^kx<n=2k。可以发现这两种情况根本不可能使得根到叶子异或和恰好为 xxx，无解。
n=3n=3n=3，不满足上一条但无法修正，此时 x=1x=1x=1 或 222，都无解。

本题做法极为丰富，一些稍复杂的做法也可通过。

:::success[Code]

#include<bits/stdc++.h>
using namespace std;
int T,n,x,f[100005],u,v,l,r;
int main(){
    cin>>T;
    while(T--){
        cin>>n>>x;
        if(n%4==0)u=v=n,x^=n,l=1,r=n-1,f[n]=0;
        if(n%4==1)u=v=1,x^=1,l=2,r=n,f[1]=0;
        if(n%4==2)u=v=1,x^=n^1,l=2,r=n-1,f[1]=n,f[n]=0;
        if(n%4==3)u=v=1,l=2,r=n-2,f[1]=n-1,f[n-1]=n,f[n]=0;
        for(int i=r;i>=l;i--)(x&i)==i?(x^=i,f[i]=u,u=i):(f[i]=v,v=i);
        if(n>3&&x==1)f[3]=u,x=0;
        if(x){cout<<"No\n";continue;}
        cout<<"Yes\n";for(int i=1;i<=n;i++)cout<<f[i]<<" \n"[i==n];
    }
    return 0;
}

:::

Code Golf!

248B 实现，来自 Bingxiu2。

#import<ios>
int n,x,u,w;main(){for(;~scanf("%d%d",&x,&w);n=w){int k=n,v=1,f[n+1]{};k&3?~k&3?x<sup>=1,k&amp;2?x</sup>=f[1]=k:++k:f[f[1]=--k]=n:x<sup>=v=k;for(u=v;n%4&gt;0&lt;--k;k&gt;x&amp;&amp;x-u?f[k]=v,v=k:x</sup>=u=k)f[k]=u;for(k=n&&!puts(x?"No":"Yes");k++<n>x;printf("%d ",f[k]));}}

P17798 [CXOI R7-B2] 晴涵梦（Hard Version）题解

Sun, 25 Oct 2026 13:36:10 GMT

Official Solution.

同样考虑 dp。设 fi,jf_{i,j}fi,j 表示因为其祖先结点不断失败，导致结点 iii 总共需要被重新通关 jjj 次时，完成 iii 为根子树这一部分所需要的最小期望代价是多少。考虑如果 iii 需要成功 jjj 次，因为单次成功的概率是 1pi\frac 1{p_i}pi1 因此期望一共挑战 jpijp_ijpi 次，即 iii 结点自身期望花费 jpicijp_ic_ijpici 的代价。

考虑如果最终要在 iii 结点存档，则显然第一次成功后直接存档要比之后存档更优。因此实际需要考虑的只有两种决策：

iii 结点一直没有存档，则此时每次挑战 iii 结点失败都会继续重置儿子结点信息，因此儿子一共需要承担 jpijp_ijpi 次。
iii 结点在第一次成功通关后立即存档。第一次成功前期望挑战次数仍然是 pip_ipi 因此儿子只需要承担最开始的这 pip_ipi 次，后续 iii 结点的失败将不会影响子树内其余结点。

因此 dp 的转移形如：fi,j=jpici+min⁡(∑kfk,jpi,ai+∑kfk,pi)f_{i,j}=jp_ic_i+\min(\sum\limits_kf_{k,jp_i},a_i+\sum\limits_kf_{k,p_i})fi,j=jpici+min(k∑fk,jpi,ai+k∑fk,pi)。但是 dp 信息的第二维可以特别大，因此显然无法直接转移。

考虑对这个 dp 做一点小小的转化。记 gi,j=fi,j−jpici−∑kfk,pig_{i,j}=f_{i,j}-jp_ic_i-\sum\limits_kf_{k,p_i}gi,j=fi,j−jpici−k∑fk,pi，则 ggg 数组的转移方程形如 gi,j=min⁡(ai,∑kpi(j−1)pkck+gk,jpi−gk,pi)g_{i,j}=\min(a_i,\sum\limits_kp_i(j-1)p_kc_k+g_{k,jp_i}-g_{k,p_i})gi,j=min(ai,k∑pi(j−1)pkck+gk,jpi−gk,pi)。

此时可以证明 gi,∗g_{i,*}gi,∗ 是一个凸函数。具体考虑归纳，注意到转移中后半部分的 pi(j−1)pkck+gk,jpi−gk,pip_i(j-1)p_kc_k+g_{k,jp_i}-g_{k,p_i}pi(j−1)pkck+gk,jpi−gk,pi 在 gk,∗g_{k,*}gk,∗ 已经被确定是凸函数时是一个凸函数加上一个线性函数的形式，再对一个常数取 min⁡\minmin 后仍然是凸函数。而对叶子结点而言显然有 gi,j=0g_{i,j}=0gi,j=0 满足凸性。因此 gi,∗g_{i,*}gi,∗ 确实是凸函数。同时还可以用类似的方法证明 gi,∗g_{i,*}gi,∗ 是单调不降的函数。

进一步简单观察 gi,∗g_{i,*}gi,∗ 的性质后可以发现必有 0≤gi,j≤ai0\le g_{i,j}\le a_i0≤gi,j≤ai 和 gi,1=0g_{i,1}=0gi,1=0。对凸函数套路的做差分后记 dj=gi,j+1−gi,jd_j=g_{i,j+1}-g_{i,j}dj=gi,j+1−gi,j。因为 gig_igi 是凸函数因此 djd_jdj 必然是非负而且单调不增的整数。一旦有某个位置 dj=0d_j=0dj=0 则 jjj 之后的所有位置 kkk 都必然满足 dk=0d_k=0dk=0。

因此此时 dp 数组的第二维只需要考虑到 ai+1a_i+1ai+1。如果此时 gi,ai+1=aig_{i,a_i+1}=a_igi,ai+1=ai 则 dp 数组的值已经取到了上界，之后所有值都是完全相同的。否则根据抽屉原理可知前 aia_iai 个位置中至少有一个位置的差分值为 000，因此后面所有位置的值同样必然保持不变。因此可以得到结论：gi,j=gi,min⁡(j,ai+1)g_{i,j}=g_{i,\min(j,a_i+1)}gi,j=gi,min(j,ai+1)。

考虑进一步优化，观察对固定的 iii 而言有效的 jjj 有哪些取值。容易发现根结点一定只有 j=1j=1j=1 的状态有效。而如果当前结点 iii，jjj 状态是有效的，则其子结点 kkk 必然只会查询到 pi,jpip_i,jp_ipi,jpi 这两个状态。因此每个状态 jjj 本质都可以看作是沿着祖先路径不断乘以某个 p∗p_*p∗ 然后对 ai+1a_i+1ai+1 取 min⁡\minmin 得到的。对结点 iii 而言记真正需要计算的 jjj 状态组成的集合为 SiS_iSi 则考虑直接从根往子树内生成，初始显然有 S1={1}S_1=\lbrace 1\rbraceS1={1}。而对 iii 的每个子结点 kkk 都有 Sk={1}∪{min⁡(ak+1,pix)∣x∈Si}S_k=\lbrace1\rbrace\cup\lbrace\min(a_k+1,p_ix)\mid x\in S_i\rbraceSk={1}∪{min(ak+1,pix)∣x∈Si}。对每个 iii 只处理 j∈Sij\in S_ij∈Si 的转移信息即可。

考虑这个时间复杂度为什么是对的。对每个 SiS_iSi 状态去重后，接下来的每一次转移若 pi=1p_i=1pi=1 则状态不会发生变化，而若 pi>1p_i>1pi>1 则每次产生一个新的状态值至少会翻倍，而因为还有 aia_iai 的上界所以最多翻 303030 次倍状态的值就不会继续增长了。因此每个结点 iii 最多只有 O(log⁡V)≈31O(\log V)\approx 31O(logV)≈31 个不同的合法状态 jjj 需要处理，直接对这个东西进行 ggg 数组的 dp，然后在 dp 过程中顺便维护 hi=∑kfk,pi=∑k(pipkck+gk,pi+hk)h_i=\sum\limits_kf_{k,p_i}=\sum\limits_k(p_ip_kc_k+g_{k,p_i}+h_k)hi=k∑fk,pi=k∑(pipkck+gk,pi+hk)，最后的答案 f1=p1c1+h1f_1=p_1c_1+h_1f1=p1c1+h1 就可以被直接计算出。总时间复杂度为 O(nlog⁡V)O(n\log V)O(nlogV)，如果实现不优美的话可能会退化到 O(nlog⁡nlog⁡V)O(n\log n\log V)O(nlognlogV) 或者 O(nlog⁡2V)O(n\log^2V)O(nlog2V)。实现上有一些细节，比如说 ggg 数组不能一边算一边取模而需要到最后 dp 完之后在取模算答案，视实现情况可能需要用 __int128 来存 dp 信息。

:::success[代码实现]

namespace ChatGPT_6_Astra_Ultra_Fast {

mt19937_64 mt(time(0));

inline void Estradiol() {
}

vector<int> adj[N], S[N], g[N];
int a[N], c[N], p[N], h[N];

inline int cap(int u, i128 x) { return min<i128>(x, a[u] + 1); }
inline int get(int u, int x) {
    x = min(x, a[u] + 1);
    return g[u][lower_bound(S[u].begin(), S[u].end(), x) - S[u].begin()];
}
inline void dfs(int u, int fa) {
    for (int &v : adj[u]) if (v != fa) {
        S[v] = {1};
        for (int &x : S[u]) {
            int y = cap(v, (i128)x * p[u]);
            if (y != S[v].back()) S[v].emplace_back(y);
        } dfs(v, u);
    }
}
inline void dfs2(int u, int fa) {
    for (int &v : adj[u]) if (v != fa) dfs2(v, u);
    g[u].clear(), g[u].resize(S[u].size(), 0);
    for (int k = 0; k < S[u].size(); ++k) if (S[u][k] > 1) {
        i128 sum = 0;
        for (int &v : adj[u]) if (v != fa) {
            int y = cap(v, (i128)S[u][k] * p[u]);
            sum += (i128)p[u] * (S[u][k] - 1) * p[v] * c[v] + get(v, y) - get(v, p[u]);
            if (sum >= a[u]) { sum = a[u]; break; }
        } g[u][k] = sum;
    } h[u] = 0;
    for (int &v : adj[u]) if (v != fa)
        h[u] = (h[u] + p[u] % mod * (p[v] % mod) % mod * (c[v] % mod) % mod + h[v] + get(v, p[u]) % mod) % mod;
}

inline void Spironolactone([[maybe_unused]]int __testcase_id, [[maybe_unused]]int __testcase_sum) {
    int n; cin >> n;
    for (int i = 1; i <= n; ++i) adj[i].clear(), S[i].clear(), g[i].clear(), h[i] = 0;
    for (int i = 1; i < n; ++i) {
        int a, b; cin >> a >> b;
        adj[a].emplace_back(b), adj[b].emplace_back(a);
    } for (int i = 1; i <= n; ++i) cin >> a[i] >> c[i] >> p[i];
    S[1] = {1}, dfs(1, 0), dfs2(1, 0), cout << ((p[1] % mod) * (c[1] % mod) + h[1]) % mod << '\n';
}

} // namespace ChatGPT_6_Astra_Ultra_Fast

:::

P17796 [CXOI R7-A] 追忆岁月题解

Sun, 25 Oct 2026 13:35:45 GMT

Official Solution.

因为 nnn 个数最多有 2n2^n2n 种选取方法，而需要覆盖的数的数量也是 2n2^n2n，这就告诉我们构造的序列 a,ba,ba,b 需要满足所有的子集的异或均两两不同。

最小值

构造 ai=2i−1a_i=2^{i-1}ai=2i−1 即可。很显然不能得到和更小的序列。

最大值

构造序列 a1=2n−1,ai=2n−2i−2−1(i≥2)a_1=2^n-1,a_i=2^n-2^{i-2}-1(i\ge 2)a1=2n−1,ai=2n−2i−2−1(i≥2)，然后翻转整个序列即可。

下面证明一下这个为什么一定取到了最大值：首先如果存在一个 aia_iai 满足二进制第 nnn 位为 000 的话，那么就算其他数全取最大值是合法的，其和也无法比现在构造的序列的和要大。

而若存在两个二进制位，其在每个 aia_iai 内的值都相同，那么对于每个选出的 aaa 的子集得到的异或值，这两个二进制位都必然相同，也就必然无法表示出所有的数。因此任意两个二进制位，都至少存在一个位置 iii 使得 aia_iai 在这两个二进制位上得到的值不同。因此其余二进制位必然不能全都是 111。

而因为剩下 n−1n-1n−1 个二进制位和 n−1n-1n−1 个 aia_iai 的值没确定，所以考虑对剩下的每个二进制位都选择一个不同的 aia_iai，把其相应的二进制位值设为 000。一个可行的方案就是 i≥2i\ge 2i≥2 都有 ai=2n−2i−2−1a_i=2^n-2^{i-2}-1ai=2n−2i−2−1，然后将 aaa 序列从小到大排序即可。因为这样构造得到的 aaa 序列是单调递减的，所以可以直接翻转。

总时间复杂度为 O(Tn)O(Tn)O(Tn)。

:::success[代码实现]

namespace Loyalty
{
    int a[N];
    inline void init() {}
    inline void main([[maybe_unused]] int _ca, [[maybe_unused]] int _atc)
    {
        int n;
        cin >> n;
        cout << 1 << '\n';
        for (int i = 1; i <= n; ++i)
            cout << (1ll << (i - 1)) << ' ';
        cout << '\n';
        a[1] = (1ll << n) - 1;
        for (int i = 2; i <= n; ++i)
            a[i] = (1ll << n) - 1 - (1ll << (i - 2));
        for (int i = n; i; --i)
            cout << a[i] << ' ';
        cout << '\n';
    }
} // namespace Loyalty

:::

当然你也可以直接写个线性基上去直接算出来序列的下一个元素，当然这就没什么必要了（）

P17797 [CXOI R7-B1] 晴涵梦（Easy Version）题解

Sun, 25 Oct 2026 13:35:13 GMT

Official Solution.

设 fi,0/1f_{i,0/1}fi,0/1 表示当前处理完了以 iii 为根的子树，且 iii 号结点通关，当前不在 / 在 iii 号点放存档，最小期望通关代价是多少。

显然对于通关概率为 1pi\frac1{p_i}pi1 的 iii 结点而言，期望需要花费 pip_ipi 次才可以通关该结点。

那么考虑转移。假设当前已经处理完了 uuu 子树内的所有点的 dp 值，现在要更新 fu,0/1f_{u,0/1}fu,0/1 的值，则套路的，考虑枚举 uuu 子树中的所有结点 vvv，则考虑每个 vvv 对 uuu 的 dp 值贡献。注意到有 fu,1=fu,0+auf_{u,1}=f_{u,0}+a_ufu,1=fu,0+au，所以你只需要处理 fu,0f_{u,0}fu,0：

vvv 点无存档，那么此时你下一次挑战 uuu 结点就需要先把 vvv 整个子树重新通关一次，即代价为 fv,0puf_{v,0}p_ufv,0pu。
vvv 点有存档，那么此时你下一次挑战 uuu 结点就只需要重新通关 vvv 结点，即代价为 fv,1+cvpv(pu−1)f_{v,1}+c_vp_v(p_u-1)fv,1+cvpv(pu−1)。

把整个 dp 状态结合起来，可得：fu,0=cupu+∑v∈son(u)min⁡(pufv,0,fv,1+(pu−1)cvpv),fu,1=fu,0+auf_{u,0}=c_up_u+\sum\limits_{v\in\text{son}(u)}\min(p_uf_{v,0},f_{v,1}+(p_u-1)c_vp_v),f_{u,1}=f_{u,0}+a_ufu,0=cupu+v∈son(u)∑min(pufv,0,fv,1+(pu−1)cvpv),fu,1=fu,0+au。直接对树做一次 dfs 遍历，总时间复杂度为 O(n)O(n)O(n) 可以通过……吗？

为什么全程使用 `__int128` 计算不会导致答案溢出？

考虑这样一个策略：

每次通关树上一个点之后，立即放一个存档。

下面考虑计算这个策略的答案。考虑对于任意一个结点 u≠1u\neq 1u=1：在其父亲结点 faufa_ufau 没有被存档之前，faufa_ufau 的挑战每失败一次，uuu 就会变为未通关一次。但是 uuu 有存档，所以此时其余结点的通关情况不会受到影响。因为父亲通关的期望尝试次数为 pfaup_{fa_u}pfau，所以 uuu 需要重新通关的期望次数也为 pfaup_{fa_u}pfau。

因此该策略的总期望花费是：∑i=1nai+c1p1+∑i=2n(cipi(pfai−1))\sum\limits_{i=1}^na_i+c_1p_1+\sum\limits_{i=2}^n(c_ip_i(p_{fa_i}-1))i=1∑nai+c1p1+i=2∑n(cipi(pfai−1))，最优值显然不会比这个更大。而对于题面中给出的数据范围，对于 ai,ci,pi≤108,n≤105a_i,c_i,p_i\le 10^8,n\le 10^5ai,ci,pi≤108,n≤105 的部分，加上上面转移过程中 fv,0f_{v,0}fv,0 还需要乘以一个 pup_upu（虽然这种情况不会更新答案）也就是说上面给出的式子的最大值在 103810^{38}1038 左右。而又有 1038<212710^{38}<2^{127}1038<2127，因此在本题的数据范围下 __int128 可以存储 dp 数组。

而对于 ai,ci,pi≤109a_i,c_i,p_i\le 10^9ai,ci,pi≤109 的部分，fv,0f_{v,0}fv,0 的最大值大约在 103210^{32}1032 左右，而因为转移过程中需要乘一个 pup_upu，这样一来两数相乘可以达到 104110^{41}1041 级别，进而导致出现 __int128 overflow。一个做法是写一个高精度，但是这十分的不优美。注意到 fv,0f_{v,0}fv,0 的值肯定不会比 103210^{32}1032 大超过一个数量级，因此考虑直接计算 fv,0f_{v,0}fv,0 和 pup_upu 的数位数，如果两数在十进制下数位数之和 ≥36\ge 36≥36，那么这样肯定是会远大于 fv,0f_{v,0}fv,0 上界的，无需更新答案。否则两数乘积一定不会超过 __int128 范围，两种情况取 min 更新答案即可。此时因为要统计一个数的位数，时间复杂度变为 O(nlog⁡n)O(n\log n)O(nlogn) 但是仍可以通过该题。

其实是很容易修改到 O(n)O(n)O(n) 的，直接用 103610^{36}1036 去除另外一个数就可以了，但是我懒得改了（）修掉了。

:::success[O(nlog⁡n)O(n\log n)O(nlogn) 代码实现]

namespace Loyalty
{
    vector<int> adj[N];
    i128 f[N][2];
    int a[N], c[N], p[N];
    inline int count_bit(i128 val)
    {
        int cnt = 0;
        do
            ++cnt, val /= 10;
        while (val);
        return cnt;
    }
    inline void dfs(int u, int fa)
    {
        f[u][0] = c[u] * p[u];
        for (int &v : adj[u])
            if (v != fa)
            {
                dfs(v, u);
                if (count_bit(p[u]) + count_bit(f[v][0]) > 36)
                    f[u][0] += f[v][1] + (i128)(p[u] - 1) * c[v] * p[v];
                else
                {
                    i128 m1 = p[u] * f[v][0];
                    i128 m2 = f[v][1] + (i128)(p[u] - 1) * c[v] * p[v];
                    f[u][0] += min(m1, m2);
                }
            }
        f[u][1] = f[u][0] + a[u];
    }
    inline void init() {}
    inline void main([[maybe_unused]] int _ca, [[maybe_unused]] int _atc)
    {
        int n;
        cin >> n;
        for (int i = 1; i <= n; ++i)
            adj[i].clear();
        for (int i = 1; i < n; ++i)
        {
            int a, b;
            cin >> a >> b;
            adj[a].emplace_back(b);
            adj[b].emplace_back(a);
        }
        for (int i = 1; i <= n; ++i)
            cin >> a[i] >> c[i] >> p[i];
        for (int i = 1; i <= n; ++i)
            f[i][0] = f[i][1] = 0;
        dfs(1, 0);
        cout << (int)(f[1][0] % mod) << '\n';
    }
} // namespace Loyalty

:::

:::success[O(n)O(n)O(n) 代码实现]

namespace lowspeed_song {

mt19937_64 mt(time(0));

inline void init() {
}

vector<int> adj[N];
i128 f[N][2];
int a[N], c[N], p[N];

constexpr i128 iinf = 3e36;

inline void dfs(int u, int fa) {
    f[u][0] = c[u] * p[u];
    for (int &v : adj[u]) if (v != fa) {
        dfs(v, u);
        if (iinf / p[u] < f[v][0]) f[u][0] += f[v][1] + (i128)(p[u] - 1) * c[v] * p[v];
        else f[u][0] += min<i128>(p[u] * f[v][0], f[v][1] + (i128)(p[u] - 1) * c[v] * p[v]);
    } f[u][1] = f[u][0] + a[u];
}

inline void sol([[maybe_unused]]int __testcase_id, [[maybe_unused]]int __testcase_sum) {
    int n; cin >> n;
    for (int i = 1; i <= n; ++i) adj[i].clear(), f[i][0] = f[i][1] = 0;
    for (int i = 1; i < n; ++i) {
        int a, b; cin >> a >> b;
        adj[a].emplace_back(b), adj[b].emplace_back(a);
    } for (int i = 1; i <= n; ++i) cin >> a[i] >> c[i] >> p[i];
    dfs(1, 0), cout << (int)(f[1][0] % mod) << '\n';
}

} // namespace lowspeed_song

:::

P3838 [IOI 2017] Toy Train 题解

Sat, 24 Oct 2026 14:56:43 GMT

有向图博弈问题考虑从外侧不断删除必败状态。设 WWW 为当前没有确定为必败的状态组成的集合。则考虑对每个点 uuu 如果其属于 AAA 集合那么只要存在一条出边通往 WWW 集合即可；如果其属于 BBB 集合必须保证其所有出边都能通往 WWW 集合。设满足这个条件的充电站组成的集合为 PPP（即 AAA 可以保证从 PPP 集合开始继续走一定能走到 WWW 集合中的某个点）。

考虑从 PPP 集合开始在反向图上跑 BFS 求出集合 XXX 表示所有能由 AAA 强制到达合适的充电站且不离开 WWW 集合的点组成的点集。则此时 W\XW\backslash XW\X 中的点无法保证可以到达合适充电站也就是当前的坏点。把所有已经离开 WWW 集合的点也看作是坏点，然后用同样的方法求出 BBB 所对应的集合 YYY，把 Y∩WY\cap WY∩W 从 WWW 集合中删除。重复上述过程直到 WWW 不再变化，最后 WWW 集合中剩下的点就是答案。

时间复杂度 O(nm)O(nm)O(nm) 可以通过该题。

// #pragma GCC optimize(3, "Ofast", "inline", "unroll-loops")
#include <bits/stdc++.h>
#include <cassert>
#include <ext/pb_ds/assoc_container.hpp>
// #define int long long

using namespace std;

bool beginmem;
constexpr int N = 1000010;
constexpr int mod = 998244353;
constexpr int i2 = mod + 1 >> 1;
// constexpr int inf = 2e18;
using ld = long double;
using i64 = long long;
using u16 = unsigned short;
using u32 = unsigned;
using u64 = unsigned long long;
using i128 = __int128;
using u128 = __uint128_t;

inline int power(int a, int b, int c) {
    int res = 1;
    while (b) {
        if (b & 1) res = 1LL * res * a % c;
        a = 1LL * a * a % c, b >>= 1;
    } return res;
}

inline int exgcd(int a, int b, int &x, int &y) {
    if (!b) return x = 1, y = 0, a;
    int xp, yp, f = exgcd(b, a % b, xp, yp);
    return x = yp, y = xp - a / b * yp, f;
}

inline int inversion(int a, int Mod = mod) { return power(a, Mod - 2, Mod); }

inline u64 splitmix64(u64 x) {
    x += 0x9e3779b97f4a7c15ULL;
    x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9ULL;
    x = (x ^ (x >> 27)) * 0x94d049bb133111ebULL;
    return x ^ (x >> 31);
}

inline void addmod(int &x, int v) { x = (x + v) % mod; }
inline void submod(int &x, int v) { x = (x + mod - v) % mod; }

vector<int> adj[N];
int deg[N], w[N], win[N], e[N], rem[N], vis[N], all[N];

vector<int> who_wins(vector<int> a, vector<int> r, vector<int> u, vector<int> v) {
    int n = a.size(), m = u.size();
    for (int i = 0; i < n; ++i) deg[i] = 0, adj[i].clear(), win[i] = w[i] = all[i] = 1;
    for (int i = 0; i < m; ++i) adj[v[i]].emplace_back(u[i]), ++deg[u[i]];
    while (1) {
        vector<int> tow(n, 0), e(n, 0);
        for (int i = 0; i < m; ++i) if (w[v[i]]) ++tow[u[i]];
        for (int i = 0; i < n; ++i) if (w[i] && r[i]) {
            if (a[i] == 1) e[i] = (int)(tow[i] > 0);
            else e[i] = (int)(tow[i] == deg[i]);
        } auto get = [&](int *allow, vector<int> &tar, int o) {
            for (int i = 0; i < n; ++i) vis[i] = 0, rem[i] = deg[i];
            queue<int> q; for (int i = 0; i < n; ++i) if (tar[i] && allow[i]) vis[i] = 1, q.emplace(i);
            while (q.size()) {
                int t = q.front(); q.pop();
                for (int &x : adj[t]) if (allow[x] && !vis[x]) {
                    if (a[x] == o) vis[x] = 1, q.emplace(x);
                    else if (!--rem[x]) vis[x] = 1, q.emplace(x);
                }
            } vector<int> res(n, 0);
            for (int i = 0; i < n; ++i) res[i] = vis[i];
            return res;
        };
        vector<int> X = get(w, e, 1), bad(n, 0);
        for (int i = 0; i < n; ++i) bad[i] = !X[i] || !w[i];
        vector<int> Y = get(all, bad, 0);
        int ok = 0; for (int i = 0; i < n; ++i)
            if (w[i] && Y[i]) w[i] = 0, ok = 1;
        if (!ok) break;
    } vector<int> res(n, 0);
    for (int i = 0; i < n; ++i) res[i] = w[i];
    return res;
}

P14238 [CCPC 2024 Shandong I] 三角形题解

Fri, 23 Oct 2026 13:15:05 GMT

先观察性质，三个串 A,B,CA,B,CA,B,C（A≥B,CA\ge B,CA≥B,C）可以组成三角形当且仅当 BC>ABC>ABC>A 或 CB>ACB>ACB>A 成立。因此考虑对串的大小关系做分类讨论。

A=B≥CA=B\ge CA=B≥C

容易证明此时 A,B,CA,B,CA,B,C 三个串一定可以构成合法的三角形。记 cntscnt_scnts 表示给定的字符串中有多少个串恰好为 sss，fsf_sfs 表示给定的字符串中有多少个字符串的字典序比 sss 小。那么该情况对答案的贡献显然就是 cntA(cntA−1)(cntA−2)6+fA×cntA(cntA−1)2\frac{cnt_A(cnt_A-1)(cnt_A-2)}6+f_A\times\frac{cnt_A(cnt_A-1)}26cntA(cntA−1)(cntA−2)+fA×2cntA(cntA−1)。

A>B,CA>B,CA>B,C

此时 A,B,CA,B,CA,B,C 可以组成三角形当且仅当 B,CB,CB,C 中至少有一个是 AAA 串的前缀。为了方便后面设 BBB 是 AAA 的前缀。则此时 AAA 串除掉 BBB 串这个前缀的剩余部分必须字典序小于 CCC 串，A,B,CA,B,CA,B,C 三个串才可以组成三角形。因此考虑建 Trie 枚举字符串的前缀 BBB，这个前缀对答案的贡献就是 cntB×max⁡(0,fB−fsuf−cntsuf)cnt_{B}\times\max(0,f_B-f_{suf}-cnt_{suf})cntB×max(0,fB−fsuf−cntsuf)，其中 sufsufsuf 是串 AAA 除了前缀 BBB 以外剩下的后缀部分。

然后这个东西就算重了，考虑容斥掉重复计算的部分。可以发现若 B>sufB>sufB>suf 则 B=CB=CB=C 的情况答案被多统计了一次，需要额外减掉 cntB(cntB+1)2\frac{cnt_B(cnt_B+1)}22cntB(cntB+1)；若两个不同前缀 B1,B2B_1,B_2B1,B2 同时满足 B>sufC,C>sufBB>suf_C,C>suf_BB>sufC,C>sufB 则答案也会被计算两次，这个部分可以把所有前缀直接按字典序排名处理。具体的，设其所有合法真前缀为 p1,p2,…,pkp_1,p_2,\ldots,p_kp1,p2,…,pk 对应的剩余后缀部分为 q1,q2,…,qkq_1,q_2,\ldots,q_kq1,q2,…,qk 则对 i<ji<ji<j，pi,pjp_i,p_jpi,pj 这两个前缀被重复计算当且仅当 pj>qi∧pi>qjp_j>q_i\land p_i>q_jpj>qi∧pi>qj，记 ai=rk(pi),bi=rk(qi)a_i=rk(p_i),b_i=rk(q_i)ai=rk(pi),bi=rk(qi) 则固定 jjj 时重复算的 iii 满足 bi<aj∧bj<ai<ajb_i<a_j\land b_j<a_i<a_jbi<aj∧bj<ai<aj 直接二维偏序处理即可。

时间复杂度为 O(nlog⁡n)O(n\log n)O(nlogn)，代码细节稍微有点多，然后稍微有点卡常。

namespace lowspeed_song {

mt19937_64 mt(time(0));

inline void init() {
}

int a[N];

struct BIT {
    int tree[N];
    inline BIT() { memset(tree, 0, sizeof tree); }
    inline void clr(int x) { for (; x < N; x += (x &- x)) tree[x] = 0; }
    inline void add(int x, int v) { for (; x < N; x += (x &- x)) tree[x] += v; }
    inline int qry(int x) { int s = 0; for (; x; x -= (x &- x)) s += tree[x]; return s; }
    inline int qry(int l, int r) { return qry(r) - qry(l - 1); }
} fwt;

char s[N];

namespace Suffix_Array {
    int sa[N], rk[N], buc[N], height[N], n, idx, id[N], len[N];
    // id[i]: 从位置 i 开始到下一个 # 为止的字符串 在所有不同字符串中的字典序的排名是多少
    struct Node {
        int x[2], buc;
        inline Node() { x[0] = x[1] = buc = 0; }
        inline Node(int a, int b, int c) { x[0] = b, x[1] = a, buc = c; }
    } a[N], b[N];
    inline void sort(int up) {
        for (int i : {0, 1}) {
            memset(buc, 0, sizeof buc);
            for (int j = 1; j <= n; ++j) ++buc[a[j].x[i]];
            for (int j = 1; j <= up; ++j) buc[j] += buc[j - 1];
            for (int j = n; j; --j) b[buc[a[j].x[i]]--] = a[j];
            for (int j = 1; j <= n; ++j) a[j] = b[j];
        }
        int idx = 1;
        rk[a[1].buc] = 1;
        for (int i = 2; i <= n; ++i)
            if (a[i].x[0] == a[i - 1].x[0] && a[i].x[1] == a[i - 1].x[1]) rk[a[i].buc] = idx;
            else rk[a[i].buc] = ++idx;
    }
    inline int build() {
        for (int i = 1; i <= n; ++i) a[i] = Node(s[i], 1, i);
        sort(128);
        for (int i = 1; i < n; i <<= 1) {
            for (int j = 1; j <= n; ++j) a[j] = Node(rk[j], (i + j <= n) ? rk[i + j] : 0, j);
            sort(n);
        } for (int i = 1; i <= n; ++i) sa[rk[i]] = i;
        for (int i = 1; i <= n; ++i)
            if (rk[i] == 1) height[rk[i]] = 0;
            else {
                int p = sa[rk[i] - 1], l = max<int>(0, height[rk[i - 1]] - 1);
                while (i + l <= n && p + l <= n && s[i + l] == s[p + l]) ++l;
                height[rk[i]] = l;
            }
        len[n + 1] = 0;
        for (int i = n; i; --i) len[i] = (s[i] == '#') ? 0 : len[i + 1] + 1;
        int las = -1, g = 0;
        for (int i = 1; i <= n; ++i) if (s[sa[i]] != '#') {
            if (!~las || len[sa[i]] != len[las] || height[i] < len[sa[i]]) ++g;
            id[sa[i]] = g, las = sa[i];
        } return g;
    }
} // namespace Suffix_Array

#define SA Suffix_Array

struct TrieNode {
    int ne[26], cnt, id;
    inline TrieNode() { memset(ne, cnt = id = 0, sizeof ne); }
} tree[N];

int idx = 0, endpos[N];

inline void ins(string s, int id) {
    int now = 0;
    for (char &i : s) {
        if (!tree[now].ne[i - 'a']) tree[now].ne[i - 'a'] = ++idx;
        now = tree[now].ne[i - 'a'];
    } ++tree[now].cnt, endpos[id] = now;
}

string str[N];
int st[N], pre[N], buc[N], vis[N], rk[N];

inline void sol([[maybe_unused]]int __testcase_id, [[maybe_unused]]int __testcase_sum) {
    int n; cin >> n;
    #define sidx SA::n
    sidx = 0;
    for (int i = 0; i < n; ++i) {
        cin >> str[i];
        st[i] = sidx + 1;
        for (char &j : str[i]) s[++sidx] = j;
        s[++sidx] = '#';
        ins(str[i], i);
    } int m = SA::build();
    fill(buc, buc + m + 1, 0), fill(vis, vis + idx + 1, 0);
    for (int i = 0; i < n; ++i) ++buc[SA::id[st[i]]], tree[endpos[i]].id = SA::id[st[i]];
    pre[1] = 0; for (int i = 2; i <= m; ++i) pre[i] = pre[i - 1] + buc[i - 1];
    i64 res = 0;
    for (int i = 0; i < n; ++i) if (!vis[endpos[i]]) {
        vis[endpos[i]] = 1;
        int cnt = tree[endpos[i]].cnt, x = pre[SA::id[st[i]]], u = 0;
        i64 now = 0;
        vector<tuple<int, int, int>> event; // {r, t, c}
        for (int j = 0; j + 1 < str[i].size(); ++j) {
            u = tree[u].ne[str[i][j] - 'a'];
            if (!tree[u].cnt) continue;
            int a = tree[u].id, b = SA::id[st[i] + j + 1];
            now += 1ll * tree[u].cnt * max<int>(0, x - pre[b] - buc[b]);
            if (a > b) now -= 1ll * tree[u].cnt * (tree[u].cnt + 1) / 2;
            event.emplace_back(a, b, tree[u].cnt);
        } vector<int> ord(event.size(), 0); ranges::iota(ord, 0);
        ranges::sort(ord, [&](int i, int j) { return get<1>(event[i]) < get<1>(event[j]); });
        for (int i = 0; i < event.size(); ++i) rk[i] = get<0>(event[i]);
        vector<int> fwt_used;
        int pos = 0;
        for (int j = 0; j < event.size(); ++j) {
            while (pos < event.size() && get<1>(event[ord[pos]]) < get<0>(event[j]))
                fwt.add(ord[pos] + 1, get<2>(event[ord[pos]])), fwt_used.emplace_back(ord[pos++] + 1);
            int las = upper_bound(rk, rk + event.size(), get<1>(event[j])) - rk;
            if (las < j) now -= 1ll * get<2>(event[j]) * fwt.qry(las + 1, j);
        } for (int &i : fwt_used) fwt.clr(i);
        res += 1ll * cnt * (cnt - 1) * (cnt - 2) / 6 + 1ll * cnt * (cnt - 1) / 2 * x + 1ll * now * cnt;
    } cout << res << '\n';
    for (int i = 0; i <= idx; ++i) tree[i] = TrieNode();
    for (int i = 0; i <= n; ++i) endpos[i] = 0;
    idx = 0, SA::idx = 0;
}

} // namespace lowspeed_song

P15942 [JOI Final 2026] 赌场 / Casino 题解

Wed, 21 Oct 2026 12:03:30 GMT

先考虑 L≤49L\le 49L≤49 怎么做。此时把平面划分为 2n−12n-12n−1 条反对角线，则每条反对角线必然被恰好翻转一个位置的值。对每条反对角线设一个校验位使得该对角线上所有奇数行位置上元素的异或和都为 000。反转完路径后考虑重新计算这个异或和，若收到的奇数行异或和为 111 则说明被反转的位置在奇数行，否则说明被反转的位置在偶数行。此时下一行的两个候选位置行号奇偶性不同，因此必然可以唯一确定被反转的位置。细节有点多。

然后考虑 L≤51L\le 51L≤51 怎么做。注意到 (1,1)(1,1)(1,1) 和 (n,n)(n,n)(n,n) 两个位置必然被反转，因此这两个位置的值根本不用进行处理，还原信息的时候直接反转即可。（有一说一这一点其实是有点困难的，至少我花了很久才注意到）

vector<vector<int>> Azzurro(int n, int L, string s) {
    vector<vector<int>> a(n, vector<int>(n, 0));
    int pp = 0;
    for (int k = 0; k < 2 * n - 1; ++k) {
        int pos = -1;
        if (k && k < 2 * n - 2) for (int i = 1; i < n; i += 2)
            if (k >= i && k - i < n) { pos = i; break; }
        for (int i = 0; i < n; ++i) {
            if (k < i || k - i >= n || i == pos) continue;
            a[i][k - i] = pp < L && s[pp] == 'B', ++pp;
        } if (~pos) for (int i = 1; i < n; i += 2)
            if (k >= i && k - i < n && i != pos) a[pos][k - pos] ^= a[i][k - i];
    } return a;
}

string Bordeaux(int n, int L, vector<vector<int>> a) {
    string s;
    int xx = 0, yy = 0;
    for (int k = 0; k < 2 * n - 1; ++k) {
        int pos = -1, oo = 0;
        if (k && k < 2 * n - 2) for (int i = 1; i < n; i += 2)
            if (k >= i && k - i < n) { if (!~pos) pos = i; oo ^= a[i][k - i]; }
        if (k == 2 * n - 2) xx = yy = n - 1;
        else if (k) ++((oo == (xx & 1)) ? yy : xx);
        a[xx][yy] ^= 1;
        for (int i = 0; i < n; ++i) if (k >= i && k - i < n && i != pos)
            s.push_back(a[i][k - i] + 'A');
    } s.resize(L);
    return s;
}

P13184 [GCJ 2017 Finals] Teleporters 题解

Thu, 15 Oct 2026 13:05:11 GMT

这里记 d(A,B)d(A,B)d(A,B) 为 A,BA,BA,B 两个点在三维空间中的曼哈顿距离。

先特判掉一些 corner case：

n=1n=1n=1 是容易解决的。
如果有一个传送器 AiA_iAi 满足 d(P,Ai)=d(Q,Ai)d(P,A_i)=d(Q,A_i)d(P,Ai)=d(Q,Ai)，则答案为 111。
否则，若存在两个传送器满足其中一个距离 PPP 更近，另外一个距离 QQQ 更近，则建系一下可知此时必然存在一组答案为 222 的构造。

处理完上面的 corner 后必然可以通过交换 P,QP,QP,Q 使得对每个传送器 AiA_iAi 都满足 d(P,Ai)<d(Q,Ai)d(P,A_i)<d(Q,A_i)d(P,Ai)<d(Q,Ai)。考虑 dp，设 fi,kf_{i,k}fi,k 表示经过 k−1k-1k−1 次传送后所有可达位置到 AiA_iAi 的最大距离是多少。初始条件为 fi,1=d(P,Ai)f_{i,1}=d(P,A_i)fi,1=d(P,Ai)，转移可以直接枚举下一个移动的位置，即 fi,k+1=max⁡j(fj,k+d(Ai,Aj))f_{i,k+1}=\max\limits_j(f_{j,k}+d(A_i,A_j))fi,k+1=jmax(fj,k+d(Ai,Aj))。然后考虑到可达区域在三维空间中是一个连续的光滑部分，因此若可以移动到的最远距离为 distdistdist，则一定可以移动到 0∼dist0\sim dist0∼dist 中的任意实数距离，也就是说只要 fi,k≥d(Q,Ai)f_{i,k}\ge d(Q,A_i)fi,k≥d(Q,Ai) 就可以在第 kkk 次传送到达 QQQ 点。

直接暴力 dp 时间复杂度肯定爆炸了，考虑经典套路拆曼哈顿距离，d(x,y)=max⁡i∈{−1,1}3i(x−y)d(x,y)=\max\limits_{i\in\lbrace-1,1\rbrace^3}i(x-y)d(x,y)=i∈{−1,1}3maxi(x−y)。因为三个 iii 的不同取值只有 888 种，因此考虑记 gs,k=max⁡i(fi,k−sAi)g_{s,k}=\max\limits_i(f_{i,k}-sA_i)gs,k=imax(fi,k−sAi)。额外记 es,t=max⁡i((t−s)Ai)e_{s,t}=\max\limits_i((t-s)A_i)es,t=imax((t−s)Ai) 后代入可以得到转移式 gs,k+1=max⁡t(es,t+gt,k)g_{s,k+1}=\max\limits_t(e_{s,t}+g_{t,k})gs,k+1=tmax(es,t+gt,k)，这可以看作是一个 8×88\times 88×8 的 (max⁡,+)(\max,+)(max,+) 矩阵乘法的形式。再预处理出 hs=max⁡i(sAi−d(Q,Ai))h_s=\max\limits_i(sA_i-d(Q,A_i))hs=imax(sAi−d(Q,Ai))，则判定 hkh_khk 对应的状态能否在第 k+1k+1k+1 次传送中到达终点只需要判定 max⁡i(gi,k+hi)≥0\max\limits_i(g_{i,k}+h_i)\ge 0imax(gi,k+hi)≥0 是否成立即可。具体实现可以对 (max⁡,+)(\max,+)(max,+) 矩阵作倍增处理，时间复杂度为 O(w2n+w3log⁡V)O(w^2n+w^3\log V)O(w2n+w3logV)，其中 VVV 是坐标的范围，www 是矩阵的边长，在本题中取 w=8w=8w=8。

描述的可能不太清楚，建议对着题解代码理解。我还是不懂这个题为什么单个测试点时间限制 110s110s110s，我的代码跑了 10ms10ms10ms 就跑过了。

namespace lowspeed_song {

mt19937_64 mt(time(0));

inline void init() {
}

struct Point { int x, y, z; } a[N];
inline int dist(Point a, Point b) {
    return abs(a.x - b.x) + abs(a.y - b.y) + abs(a.z - b.z);
}

const i128 inf = (i128)1 << 120;

i128 e[45][8][8], g[8], h[8], tmp[8], d[160][8];

inline void in(Point &p) { cin >> p.x >> p.y >> p.z; }

inline void sol([[maybe_unused]]int __testcase_id, [[maybe_unused]]int __testcase_sum) {
    int n; cin >> n;
    Point p, q; in(p), in(q);
    for (int i = 0; i < n; ++i) in(a[i]);
    cout << "Case #" << __testcase_id << ": ";
    int o1 = 0, o2 = 0, o3 = 0;
    for (int i = 0; i < n; ++i) {
        int d1 = dist(p, a[i]), d2 = dist(q, a[i]);
        o1 |= (d1 < d2), o2 |= (d1 > d2), o3 |= (d1 == d2);
    } if (o3) { cout << 1 << '\n'; return; }
    if (n == 1) { cout << "IMPOSSIBLE\n"; return; }
    if (o1 && o2) { cout << 2 << '\n'; return; }
    if (o2) swap(p, q);
    for (int i = 0; i < 8; ++i) g[i] = h[i] = -inf;
    for (int i = 0; i < n; ++i) for (int j = 0; j < 8; ++j) {
        d[i][j] = 0;
        d[i][j] += (j & 1) ? a[i].x : -a[i].x;
        d[i][j] += (j & 2) ? a[i].y : -a[i].y;
        d[i][j] += (j & 4) ? a[i].z : -a[i].z;
        g[j] = max(g[j], (i128)dist(p, a[i]) - d[i][j]);
        h[j] = max(h[j], (i128)d[i][j] - dist(q, a[i]));
    } auto chk = [&](i128 *f) {
        for (int i = 0; i < 8; ++i) if (f[i] + h[i] >= 0) return 1;
        return 0;
    }; if (chk(g)) { cout << 2 << '\n'; return; }
    for (int i = 0; i < 8; ++i) for (int j = 0; j < 8; ++j) {
        e[0][i][j] = -inf; for (int k = 0; k < n; ++k)
            e[0][i][j] = max(e[0][i][j], d[k][j] - d[k][i]);
    } for (int k = 1; k < 45; ++k) for (int i = 0; i < 8; ++i) for (int j = 0; j < 8; ++j) {
        e[k][i][j] = -inf; for (int p = 0; p < 8; ++p)
            e[k][i][j] = max(e[k][i][j], e[k - 1][i][p] + e[k - 1][p][j]);
    } int res = 0; for (int i = 44; ~i; --i) {
        for (int j = 0; j < 8; ++j) {
            tmp[j] = -inf;
            for (int k = 0; k < 8; ++k) tmp[j] = max(tmp[j], g[k] + e[i][j][k]);
        } if (!chk(tmp)) copy(tmp, tmp + 8, g), res |= (1ll << i);
    } cout << res + 3 << '\n';
}

} // namespace lowspeed_song

P17571 「FAOI-R(-2)」数列计数 2024 题解

Thu, 15 Oct 2026 11:25:50 GMT

不需要线代和 GF 的 2log⁡2\log2log 做法，感觉应该不太能继续优化时间复杂度了。

先考虑一个线性的暴力做法。设 f(n)f(n)f(n) 为答案，则初始条件为 f(1)=f(2)=1f(1)=f(2)=1f(1)=f(2)=1，转移方程为 f(n)=∑i=⌈n2⌉n−1f(i)f(n)=\sum\limits_{i=\lceil\frac n2\rceil}^{n-1}f(i)f(n)=i=⌈2n⌉∑n−1f(i)，拿前缀和优化一下可以做到线性。

考虑进一步优化。如果你做过 QOJ 20020 的话可以很轻松的想到倍增同时维护相邻两项 f(2k),f(2k+1)f(2k),f(2k+1)f(2k),f(2k+1) 的值然后相互转移。具体的，有：

f(2k)=2f(2k−1)f(2k)=2f(2k-1)f(2k)=2f(2k−1)（k>1k>1k>1）
f(2k+1)=2f(2k)−f(k)f(2k+1)=2f(2k)-f(k)f(2k+1)=2f(2k)−f(k)（k≥1k\ge1k≥1）

直接把这个倍增型的递推暴力转开，可得 f(n)=2n−2−∑i=1⌊n−12⌋2n−2i−1f(i)f(n)=2^{n-2}-\sum\limits_{i=1}^{\lfloor\frac{n-1}2\rfloor}2^{n-2i-1}f(i)f(n)=2n−2−i=1∑⌊2n−1⌋2n−2i−1f(i) 即 f(n)=2n−2(1−2∑i=1⌊n−12⌋f(i)4i)f(n)=2^{n-2}(1-2\sum\limits_{i=1}^{\lfloor\frac{n-1}2\rfloor}\frac{f(i)}{4^i})f(n)=2n−2(1−2i=1∑⌊2n−1⌋4if(i))，问题在于如何快速的求出这个带幂次系数的前缀和。记 g0=14,gi+1=gi2,hj(n)=∑i=1nf(i)gjig_0=\frac14,g_{i+1}=g_i^2,h_j(n)=\sum\limits_{i=1}^nf(i)g_j^ig0=41,gi+1=gi2,hj(n)=i=1∑nf(i)gji 则上面的转移可以被表示为 f(n)=2n−2(1−2h0(⌊n−12⌋))f(n)=2^{n-2}(1-2h_0(\lfloor\frac{n-1}2\rfloor))f(n)=2n−2(1−2h0(⌊2n−1⌋))。然后考虑递推 h∗(n)h_*(n)h∗(n)，对上面的式子做一些简单的变化可得转移 hj(n)=gj−gj2−gjsj+1(⌊n−12⌋)−2f(n)gjn+11−2gjh_j(n)=\frac{g_j-g_j^2-g_js_{j+1}(\lfloor\frac{n-1}2\rfloor)-2f(n)g_j^{n+1}}{1-2g_j}hj(n)=1−2gjgj−gj2−gjsj+1(⌊2n−1⌋)−2f(n)gjn+1，初始条件为 hj(0)=0,hj(1)=gjh_j(0)=0,h_j(1)=g_jhj(0)=0,hj(1)=gj。

考虑直接暴力递归下取处理，可以发现求 f(n)f(n)f(n) 时只需要求 h0(⌊n−12)⌋h_0(\lfloor\frac{n-1}2)\rfloorh0(⌊2n−1)⌋，而求 hj(n)h_j(n)hj(n) 只需要求 f(n)f(n)f(n) 和 hj+1(⌊n−12⌋)h_{j+1}(\lfloor\frac{n-1}2\rfloor)hj+1(⌊2n−1⌋) 的值，即每一轮递归下标都会折半。而每一层需要维护的不同 jjj 的值是 O(log⁡n)O(\log n)O(logn) 级别的，因此直接暴力算时间复杂度就是 O(log⁡2n)O(\log^2n)O(log2n) 的，可以非常轻松通过该题。

namespace lowspeed_song {

mt19937_64 mt(time(0));

inline void init() {
}

inline vector<int> conv(vector<int> a, vector<int> b) {
    vector<int> c(a.size() + b.size() - 1, 0);
    for (int i = 0; i < a.size(); ++i) for (int j = 0; j < b.size(); ++j)
        addmod(c[i + j], a[i] * b[j] % mod);
    return c;
}

inline vector<int> neg(vector<int> a) {
    for (int i = 1; i < a.size(); i += 2) a[i] = (mod - a[i]) % mod;
    return a;
}

inline vector<int> get(vector<int> a, int b) {
    vector<int> c;
    for (int i = b; i < a.size(); i += 2) c.emplace_back(a[i]);
    if (c.empty()) c.emplace_back(0);
    return c;
}

inline int solve(int n) {
    vector<int> c = {0}, d = {1}, e = {1};
    while (n) {
        vector<int> a = conv(e, {1, mod - 2}), b = neg(a);
        vector<int> A = conv(c, {1, mod - 2}), B = conv(d, {0, 1, mod - 1});
        A.resize(max(A.size(), B.size()));
        for (int i = 0; i < B.size(); ++i) addmod(A[i], B[i]);
        B = conv(d, {0, mod - 1}), c = get(conv(A, b), n & 1), d = get(conv(B, b), n & 1), e = get(conv(a, b), 0), n >>= 1;
    } return c[0];
}

int cnt[N], S[N];

inline void sol([[maybe_unused]]int __testcase_id, [[maybe_unused]]int __testcase_sum) {
    int n; cin >> n;
    cout << solve(n) << '\n';
}

} // namespace lowspeed_song

P17618 [Math+Girl×1] dancing With Myself in the sunset / Wheels Mst 题解

Tue, 06 Oct 2026 11:47:11 GMT

AI 使用声明：前半部分和最后的线性算答案部分做法是 ChatGPT 教我的。

被官方题解的一大堆积分吓哭了，所以这里给出一个完全不需要任何高等数学知识的题解。

先不考虑额外加入的一条弦。固定一个 1∼2n1\sim 2n1∼2n 的边权排列，设她的 MST 中 nnn 条边的权值为 a1<a2<…<ana_1<a_2<\ldots<a_na1<a2<…<an。记 cic_ici 表示只保留权值 ≤i\le i≤i 的边后图的连通块数量。则考虑 Kruskal 处理完前 kkk 个权值后森林中边数必然为 n+1−ckn+1-c_kn+1−ck，此时这些边必然就是 MST 内权值 ≤k\le k≤k 的边，因此可以得到关系 ck−1=∑i=1n[ai>k]c_k-1=\sum\limits_{i=1}^n[a_i>k]ck−1=i=1∑n[ai>k]，简单推导一下可得 ∑i=02n(ci−1)=∑i=1nai\sum\limits_{i=0}^{2n}(c_i-1)=\sum\limits_{i=1}^na_ii=0∑2n(ci−1)=i=1∑nai 也就是 MST 上边权的和。

考虑把所有 1∼2n1\sim 2n1∼2n 的排列对上面的式子求和，即 ∑π∑i=02n(cπ,i−1)\sum\limits_{\pi}\sum\limits_{i=0}^{2n}(c_{\pi,i}-1)π∑i=0∑2n(cπ,i−1)，交换求和顺序得 ∑i=02n∑π(cπ,i−1)\sum\limits_{i=0}^{2n}\sum\limits_{\pi}(c_{\pi,i}-1)i=0∑2nπ∑(cπ,i−1)。此时对固定的 iii 而言 ci−1c_i-1ci−1 就是不含有中心点的连通块数量。此时把外圈长度为 lll 的连通块记作 III，记 [I is component][\text{I is component}][I is component] 的值为 111 当且仅当 III 是一个不含有中心的连通块，则 cπ,k−1=∑i=1n∑∣I∣=i[I is component]c_{\pi,k}-1=\sum\limits_{i=1}^n\sum\limits_{|I|=i}[\text{I is component}]cπ,k−1=i=1∑n∣I∣=i∑[I is component]，上面的和式的值就是 ∑i=1n∑∣I∣=i∑j=02n∑π[I is component]\sum\limits_{i=1}^n\sum\limits_{|I|=i}\sum\limits_{j=0}^{2n}\sum\limits_{\pi}[\text{I is component}]i=1∑n∣I∣=i∑j=0∑2nπ∑[I is component]。

考虑把 i<ni<ni<n 和 i=ni=ni=n 分开讨论算答案。

i<ni<ni<n

固定一个长度为 iii 的部分 III，则其内部有 i−1i-1i−1 条外圈边必须满足其权值 ≤k\le k≤k，而 iii 条从中心连向外侧的边和两条边界的外圈边必须满足权值 >k>k>k。剩余边的数量为 2n−2i−12n-2i-12n−2i−1。因此固定 l,k,Il,k,Il,k,I 时排列数为 (ki−1)(i−1)!(2n−ki+2)(i+2)!(2n−2i−1)!=(k!(2n−k)!(2n−2i−1)!(k−i+1)!(2n−k−i−2)!)=(2n−2i−1k−i+1)k!(2n−k)!\binom{k}{i-1}(i-1)!\binom{2n-k}{i+2}(i+2)!(2n-2i-1)!=\binom{k!(2n-k)!(2n-2i-1)!}{(k-i+1)!(2n-k-i-2)!}=\binom{2n-2i-1}{k-i+1}k!(2n-k)!(i−1k)(i−1)!(i+22n−k)(i+2)!(2n−2i−1)!=((k−i+1)!(2n−k−i−2)!k!(2n−k)!(2n−2i−1)!)=(k−i+12n−2i−1)k!(2n−k)!。而长度为 iii 的连续外圈段一共有 nnn 个，因此这个部分的答案就是 n∑i=1n−1∑k=02n(2n−2i−1k−i+1)k!(2n−k)!n\sum\limits_{i=1}^{n-1}\sum\limits_{k=0}^{2n}\binom{2n-2i-1}{k-i+1}k!(2n-k)!ni=1∑n−1k=0∑2n(k−i+12n−2i−1)k!(2n−k)!。

i=ni=ni=n

此时整个外圈部分构成了一个连通块，而所有 nnn 条从中间连向外侧的边都必须满足权值 >wk>w_k>wk，而外圈的 nnn 条边中至少有 n−1n-1n−1 条满足权值 ≤k\le k≤k，所以此时当且仅当 k∈{n−1,n}k\in\lbrace n-1,n\rbracek∈{n−1,n} 时答案非 000。这个部分可以简单分类讨论一下：

k=nk=nk=n：贡献为 (n!)2(n!)^2(n!)2。
k=n−1k=n-1k=n−1，贡献为 n(n−1)!(n+1)!=(n!)2(n+1)n(n-1)!(n+1)!=(n!)^2(n+1)n(n−1)!(n+1)!=(n!)2(n+1)。

把贡献加起来可得该部分对答案的贡献为 (n+2)(n!)2(n+2)(n!)^2(n+2)(n!)2。

把 i<ni<ni<n 和 i=ni=ni=n 的部分合起来，总的贡献就是 (n+2)(n!)2+n∑i=1n−1∑k=02n(2n−2i−1k−i+1)k!(2n−k)!(n+2)(n!)^2+n\sum\limits_{i=1}^{n-1}\sum\limits_{k=0}^{2n}\binom{2n-2i-1}{k-i+1}k!(2n-k)!(n+2)(n!)2+ni=1∑n−1k=0∑2n(k−i+12n−2i−1)k!(2n−k)!。直接算时间复杂度是 O(n2)O(n^2)O(n2) 的，核心难点在于如何快速计算中间的 ∑i=1n−1∑k=02n(2n−2i−1k−i+1)k!(2n−k)!\sum\limits_{i=1}^{n-1}\sum\limits_{k=0}^{2n}\binom{2n-2i-1}{k-i+1}k!(2n-k)!i=1∑n−1k=0∑2n(k−i+12n−2i−1)k!(2n−k)!。考虑换元，记 j=k−i+1,m=2n−2i−1j=k-i+1,m=2n-2i-1j=k−i+1,m=2n−2i−1，则：

∑k(2n−2i−1k−i+1)k!(2n−k)!=∑j=0m(mj)(i+j−1)!(m−j+i+2)!=m!(i−1)!(i+2)!∑j=0m(i+j−1i−1)(m−j+i+2i+2)=m!(i−1)!(i+2)!(m+2i+22i+2)=(2n+1)!(i−1)!(i+2)!(2i+2)!\begin{aligned} &\sum\limits_k\binom{2n-2i-1}{k-i+1}k!(2n-k)!\\ =&\sum\limits_{j=0}^m\binom mj(i+j-1)!(m-j+i+2)!\\ =&m!(i-1)!(i+2)!\sum\limits_{j=0}^m\binom{i+j-1}{i-1}\binom{m-j+i+2}{i+2}\\ =&m!(i-1)!(i+2)!\binom{m+2i+2}{2i+2}\\ =&\frac{(2n+1)!(i-1)!(i+2)!}{(2i+2)!} \end{aligned}====k∑(k−i+12n−2i−1)k!(2n−k)!j=0∑m(jm)(i+j−1)!(m−j+i+2)!m!(i−1)!(i+2)!j=0∑m(i−1i+j−1)(i+2m−j+i+2)m!(i−1)!(i+2)!(2i+2m+2i+2)(2i+2)!(2n+1)!(i−1)!(i+2)!

然后再考虑加弦的情况。加入一条弦 (1,x)(1,x)(1,x) 后总边数变为 2n+12n+12n+1。考虑从不加弦的情况扩展而来就是把贡献拆分为原来的部分加上新变化的部分，而新变化的部分就是这条弦带来的实际减小量。固定加弦之后的一个边权排列，设新弦 (1,x)(1,x)(1,x) 的权值为 www，则暂时删掉这条弦之后记 ttt 是最小的 kkk 权值满足只考虑权值 ≤k\le k≤k 的边时 1,x1,x1,x 两个点在图上已经连通。那么考虑分类讨论对答案的影响：

若 k<wk<wk<w，则弦还没有出现，不会有任何影响。
若 w≤k<tw\le k<tw≤k<t，则弦已经出现，但是 1,x1,x1,x 两个点原本还没有连通，因此此时弦会让连通块的数量减少 111。
若 k≥tk\ge tk≥t，则原图中 1,x1,x1,x 两个点本身就连通，弦不会对连通块数量产生影响。

因此很容易发现减少的量的和就是 max⁡(0,t−w)\max(0,t-w)max(0,t−w)。接下来只要统计弦已经出现但是 1,x1,x1,x 在原来的图中仍然是不连通的方案数即可。假设固定了 aaa 条边的时候必须满足权值 ≤k\le k≤k，固定了 bbb 条边的时候必须满足权值 >k>k>k，则固定 kkk 时对应的合法排列数就是 (ka)a!(2n+1−kb)b!(2n+1−a−b)!\binom kaa!\binom{2n+1-k}bb!(2n+1-a-b)!(ak)a!(b2n+1−k)b!(2n+1−a−b)!，对所有 kkk 求和后答案就是 ∑k(ka)a!(2n+1−kb)b!(2n+1−a−b)!=a!b!(2n+1−a−b)!∑k(ka)(2n+1−kb)=a!b!(2n+1−a−b)!(2n+2a+b+1)=(2n+2)!a!b!(a+b+1)!\sum\limits_k\binom kaa!\binom{2n+1-k}bb!(2n+1-a-b)!=a!b!(2n+1-a-b)!\sum\limits k\binom ka\binom{2n+1-k}b=a!b!(2n+1-a-b)!\binom{2n+2}{a+b+1}=(2n+2)!\frac{a!b!}{(a+b+1)!}k∑(ak)a!(b2n+1−k)b!(2n+1−a−b)!=a!b!(2n+1−a−b)!∑k(ak)(b2n+1−k)=a!b!(2n+1−a−b)!(a+b+12n+2)=(2n+2)!(a+b+1)!a!b!。为了方便，后面记 F(a,b)=a!b!(a+b+1)!F(a,b)=\frac{a!b!}{(a+b+1)!}F(a,b)=(a+b+1)!a!b!，上面的贡献也可以被表示为 (2n+2)!F(a,b)(2n+2)!F(a,b)(2n+2)!F(a,b)。然后考虑只看外圈权值 ≤k\le k≤k 的边，设 C1,CxC_1,C_xC1,Cx 分别是 1,x1,x1,x 两个点所在的外圈连通块。则 1,x1,x1,x 两个点不连通当且仅当 C1≠CxC_1\neq C_xC1=Cx 且 1,x1,x1,x 不能通过中心点来连通。当 C1≠CxC_1\neq C_xC1=Cx 时两个点通过中心连通当且仅当 C1C_1C1 中存在一条连接到中心点的边 ≤k\le k≤k 且 CxC_xCx 中存在一条连接到中心点的边 ≤k\le k≤k，容斥一下可知不合法情况就是 C1C_1C1 中所有连向中心点的边权值 >k>k>k 且 CxC_xCx 中所有连向中心点的边权值 >k>k>k。设 AAA 表示只要求 C1C_1C1 没有可用连向中心点的边的贡献，BBB 表示 C1,CxC_1,C_xC1,Cx 都没有可用连向中心点的边的贡献，则总减少的量就是 2A−B2A-B2A−B（C1,CxC_1,C_xC1,Cx 两侧的贡献是对称相同的）。

考虑先计算 AAA 的值。沿着长度为 ddd 的路径从 111 开始有连续 ppp 条外圈边满足 ≤k\le k≤k 然后遇到第一条 >k>k>k 的边，沿着另外一条长度为 eee 的路径同样有连续 qqq 条边权 ≤k\le k≤k 的边然后遇到第一条 >k>k>k 的边，则必然有 0≤p<d∧0≤q<e0\le p<d\land 0\le q<e0≤p<d∧0≤q<e，则此时 C1C_1C1 一共有 p+q+1p+q+1p+q+1 个点，必须满足边权 ≤k\le k≤k 的边的数量是 p+q+1p+q+1p+q+1。必须满足边权 >k>k>k 的边有两条阻断 C1C_1C1 的外圈边和 C1C_1C1 上的 p+q+1p+q+1p+q+1 条连向中心点的边，因此有 b=p+q+3b=p+q+3b=p+q+3。因此可以计算出 A=(2n+2)!∑i=0d−1∑j=0e−1F(i+j+1,i+j+3)A=(2n+2)!\sum\limits_{i=0}^{d-1}\sum\limits_{j=0}^{e-1}F(i+j+1,i+j+3)A=(2n+2)!i=0∑d−1j=0∑e−1F(i+j+1,i+j+3)。

然后再考虑计算 BBB 的值，此时单独考虑一条长度为 LLL 的路径，设从左右两个端点开始出发，分别由连续 p,qp,qp,q 条外圈边满足其边权均 ≤k\le k≤k。则若 p+q≤L−2p+q\le L-2p+q≤L−2，则左右两侧遇到的是两条不同的边权 >k>k>k 的边，且满足 p+q=sp+q=sp+q=s 的方案有 s+1s+1s+1 种。而若 p+q=L−1p+q=L-1p+q=L−1，则两侧遇到的是同样一条边，而且这条边是唯一一条在外侧满足边权 >k>k>k 的边。这条边可以处于 LLL 个位置中的任意一个，因此有 LLL 种不同的方案，也就是两题奥路径分别有普通情况和只断一条边的两种情况，考虑对四种情况作分类讨论：

若两条路径都至少剩下两条没有确定的边界，则设对应参数为 0≤p≤d−2,0≤q≤e−20\le p\le d-2,0\le q\le e-20≤p≤d−2,0≤q≤e−2，则方案数的系数为 (p+1)(q+1)(p+1)(q+1)(p+1)(q+1)，必须在前面的边就是 p+q+1p+q+1p+q+1 条，必须在后面的边就是两个端点自己连向中心点的两条边，两条路径的一共四条断边和剩下的属于 C1,CxC_1,C_xC1,Cx 的 p+qp+qp+q 个点连向中间点的 p+qp+qp+q 条边，一共是 p+q+6p+q+6p+q+6 条边，对答案的贡献就是 ∑p=0d−2∑q=0e−2(p+1)(q+1)F(p+q+1,p+q+6)\sum\limits_{p=0}^{d-2}\sum\limits_{q=0}^{e-2}(p+1)(q+1)F(p+q+1,p+q+6)p=0∑d−2q=0∑e−2(p+1)(q+1)F(p+q+1,p+q+6)。

若长度为 ddd 的路径有两条没确定的边界，而长度为 eee 的路径只有一条断掉的边，则因为后者有 eee 种断边的方法，所以总的贡献就是 e∑p=0d−2(p+1)F(p+e,p+e+4)e\sum\limits_{p=0}^{d-2}(p+1)F(p+e,p+e+4)ep=0∑d−2(p+1)F(p+e,p+e+4)。而若长度为 eee 的路径有两条没有确定的边界，而长度为 ddd 的路径只有一条断掉的边，则贡献反过来就是 d∑q=0e−2(q+1)F(d+q,d+q+4)d\sum\limits_{q=0}^{e-2}(q+1)F(d+q,d+q+4)dq=0∑e−2(q+1)F(d+q,d+q+4)。最后一类情况是两条路径都只有一条断的边，则此时边权必须 ≤k\le k≤k 的边的数量为 n−1n-1n−1，必须 >k>k>k 的边的数量为 n+2n+2n+2，总的贡献就是 deF(n−1,n+2)deF(n-1,n+2)deF(n−1,n+2)。

直接把四类贡献合并起来求和时间复杂度为 O(n2)O(n^2)O(n2)，考虑进一步优化。为了方便，记 ur=F(r+1,r+3),vr=F(r+1,r+6),qr=F(r,r+4),Ad=∑i=0d−1∑j=0e−1ui+j,Bd=∑i=0d−2∑j=0e−2(i+1)(j+1)vi+j,Cd=∑i=en−2(i−e+1)qi,Dd=∑i=dn−2(i−d+1)qiu_r=F(r+1,r+3),v_r=F(r+1,r+6),q_r=F(r,r+4),A_d=\sum\limits_{i=0}^{d-1}\sum\limits_{j=0}^{e-1}u_{i+j},B_d=\sum\limits_{i=0}^{d-2}\sum\limits_{j=0}^{e-2}(i+1)(j+1)v_{i+j},C_d=\sum\limits_{i=e}^{n-2}(i-e+1)q_i,D_d=\sum\limits_{i=d}^{n-2}(i-d+1)q_iur=F(r+1,r+3),vr=F(r+1,r+6),qr=F(r,r+4),Ad=i=0∑d−1j=0∑e−1ui+j,Bd=i=0∑d−2j=0∑e−2(i+1)(j+1)vi+j,Cd=i=e∑n−2(i−e+1)qi,Dd=i=d∑n−2(i−d+1)qi，则减少量可以被表示为 (2n+2)!(2Ad−Bd−eCd−dDd−deF(n−1,n+2))(2n+2)!(2A_d-B_d-eC_d-dD_d-deF(n-1,n+2))(2n+2)!(2Ad−Bd−eCd−dDd−deF(n−1,n+2)) 的形式，问题在于怎么对所有的 ddd 在线性时间内求出上面的所有量。

考虑先维护 AdA_dAd 的值。记 Fd=∑i=dn−2ui,Gd=∑i=e−1n−2uiF_d=\sum\limits_{i=d}^{n-2}u_i,G_d=\sum\limits_{i=e-1}^{n-2}u_iFd=i=d∑n−2ui,Gd=i=e−1∑n−2ui，则当 ddd 自增 111，eee 自减 111 的时候，变化量显然就是 Ad+1−Ad=Pd−QdA_{d+1}-A_d=P_d-Q_dAd+1−Ad=Pd−Qd，同时 Pd+1−Pd=−ud,Qd+1−Qd=ue−2P_{d+1}-P_d=-u_d,Q_{d+1}-Q_d=u_{e-2}Pd+1−Pd=−ud,Qd+1−Qd=ue−2。然后用类似的方式维护 BdB_dBd，记 Rd=∑i=d−1n−4(i−d+2)vi,Fd′=∑i=d−1n−4vi,Cd=∑i=e−2n−4(i−e+3)vi,Gd′=∑i=e−2n−4viR_d=\sum\limits_{i=d-1}^{n-4}(i-d+2)v_i,F'_d=\sum\limits_{i=d-1}^{n-4}v_i,C_d=\sum\limits_{i=e-2}^{n-4}(i-e+3)v_i,G'_d=\sum\limits_{i=e-2}^{n-4}v_iRd=i=d−1∑n−4(i−d+2)vi,Fd′=i=d−1∑n−4vi,Cd=i=e−2∑n−4(i−e+3)vi,Gd′=i=e−2∑n−4vi，则同样考虑 ddd 自增 111，eee 自减 111 时的变化量，可以发现 Bd+1−Bd=dRd−(e−1)CdB_{d+1}-B_d=dR_d-(e-1)C_dBd+1−Bd=dRd−(e−1)Cd，递推另外四个量可以得到 Rd+1−Rd=−Fd′,Cd+1−Cd=Gd+1′,Fd+1′−Fd′=−vd−1,Gd+1′−Gd′=ve−3R_{d+1}-R_d=-F'_d,C_{d+1}-C_d=G'_{d+1},F'_{d+1}-F'_d=-v_{d-1},G'_{d+1}-G'_d=v_{e-3}Rd+1−Rd=−Fd′,Cd+1−Cd=Gd+1′,Fd+1′−Fd′=−vd−1,Gd+1′−Gd′=ve−3。Fd,GdF_d,G_dFd,Gd 的变化量则同样可以借助前面提到的 C∗,D∗C_*,D_*C∗,D∗ 进行转移，这里就不再赘述了。因此上述所有信息都可以 O(1)O(1)O(1) 的从 ddd 更新到 d+1d+1d+1 的信息，总时间复杂度也就是 O(n)O(n)O(n) 的了。

代码写丑了，可能会被卡常。

namespace lowspeed_song {

mt19937_64 mt(time(0));

int fac[N], inv[N], ifac[N];

inline void init() {
    fac[0] = 1;
    for (int i = 1; i < N; ++i) fac[i] = fac[i - 1] * i % mod;
    ifac[N - 1] = inversion(fac[N - 1]);
    for (int i = N - 2; ~i; --i) ifac[i] = ifac[i + 1] * (i + 1) % mod;
    // fac[0] = inv[0] = ifac[0] = 1;
    // fac[1] = inv[1] = ifac[1] = 1;
    // for (int i = 2; i < N; ++i) {
    //     fac[i] = fac[i - 1] * i % mod;
    //     inv[i] = mod - inv[mod % i] * (mod / i) % mod;
    //     ifac[i] = ifac[i - 1] * inv[i] % mod;
    // }
}

inline int binom(int a, int b) {
    if (b < 0 || a < b) return 0;
    return fac[a] * ifac[b] % mod * ifac[a - b] % mod;
}

inline int F(int a, int b) { return fac[a] * fac[b] % mod * ifac[a + b + 1] % mod; };
inline void sol([[maybe_unused]]int __testcase_id, [[maybe_unused]]int __testcase_sum) {
    int n; cin >> n;
    int sum = 0;
    for (int i = 1; i < n; ++i) addmod(sum, F(i - 1, i + 2));
    int S = ((n + 2) * fac[n] % mod * fac[n] + n * fac[n + n + 1] % mod * sum) % mod, bs = S * (n + n + 2) % mod;
    int A = 0, v1 = 0, v2 = F(n - 1, n + 1), R = 0, v3 = 0, N = 0, v4 = 0;
    for (int i = 0; i <= n - 2; ++i) {
        addmod(A, F(i + 1, i + 3));
        if (i) addmod(v1, F(i + 1, i + 3));
        if (i < n - 3) addmod(v3, F(i + 1, i + 6)), addmod(R, F(i + 1, i + 6) * (i + 1) % mod);
        if (i) addmod(v4, F(i, i + 4)), addmod(N, F(i, i + 4) * i % mod);
    } int B = 0, C = 0, M = 0, v5 = 0, v6 = 0;
    for (int i = 1; i < n / 2; ++i) {
        addmod(A, (v1 - v2 + mod) % mod);
        addmod(v2, F(n - i - 1, n - i + 1)), submod(v1, F(i + 1, i + 3));
        addmod(B, (i * R - C * (n - i - 1) % mod + mod) % mod);
        submod(R, v3);
        if (i - 1 <= n - 4) submod(v3, F(i, i + 5));
        if (n - i > 2 && n - i - 3 <= n - 4) addmod(v6, F(n - i - 2, n - i + 3));
        addmod(C, v6), submod(N, v4);
        if (i < n - 1) submod(v4, F(i, i + 4));
        addmod(v5, F(n - i - 1, n - i + 3)), addmod(M, v5);
        int val = 2 * A % mod;
        submod(val, B), submod(val, (n - (i + 1)) * M % mod);
        submod(val, (i + 1) * N % mod);
        submod(val, (i + 1) * (n - (i + 1)) % mod * F(n - 1, n + 2) % mod);
        cout << (bs - val * fac[n + n + 2] % mod + mod) % mod << ' ';
    } cout << '\n';
}

} // namespace lowspeed_song

CF2262E Paired Bracket Sequences 题解

Mon, 21 Sep 2026 12:22:54 GMT

怎么全世界都觉得这个是黑题，来写一个简单做法的题解。

为了方便，后面记 Ci=(2ii)i+1C_i=\frac{\binom{2i}i}{i+1}Ci=i+1(i2i) 为 Catalan 数列。

直接做比较困难，因此考虑容斥。钦定有 kkk 对公共配对，剩下部分被分成了 k+1k+1k+1 个连续段。若某一段有 xxx 对括号则两个序列在这一块可以分别任取合法序列，贡献就是 Cx2C_x^2Cx2。

因此考虑 dp。设 fi,jf_{i,j}fi,j 表示当前考虑了前 i+1i+1i+1 个连续段，放了 jjj 对普通括号的方案权值的和是多少。初始条件显然就是 f0,j=Cj2f_{0,j}=C_j^2f0,j=Cj2，转移枚举下一段的长度 fi,j+k←fi−1,jCk2f_{i,j+k}\leftarrow f_{i-1,j}C_k^2fi,j+k←fi−1,jCk2。此时 fi,n−if_{i,n-i}fi,n−i 的含义就是标记了 iii 个配对后剩下 n−in-in−i 对括号的配对方案数。由结论可知标记 kkk 个公共配对的总方案数为 (2nk)k+1fk,n−k\frac{\binom{2n}k}{k+1}f_{k,n-k}k+1(k2n)fk,n−k，二项式反演回去就可以算出答案。时间复杂度 O(n3)O(n^3)O(n3)，好像能用一些科技继续优化时间复杂度但是没啥必要。

::::info[(2nk)k+1\frac{\binom{2n}k}{k+1}k+1(k2n) 是什么？]{open} 这个结论可以理解为是 kkk 个配对把整个结构连接成一个 k+1k+1k+1 个块组成的树。设 k+1k+1k+1 个块的大小分别为 v1,v2,…,vk+1v_1,v_2,\ldots,v_{k+1}v1,v2,…,vk+1，则必有 ∑vj=n−k\sum v_j=n-k∑vj=n−k，这些块内部的方案数加起来就是 Fv1Fv2…Fvk+1F_{v_1}F_{v_2}\ldots F_{v_{k+1}}Fv1Fv2…Fvk+1，为了方便这里记 Fi=Ci2F_i=C_i^2Fi=Ci2。把所有可能的 v1,v2,…,vk+1v_1,v_2,\ldots,v_{k+1}v1,v2,…,vk+1 对答案的贡献求和得到 ∑v1+v2+…+vk+1=n−kFv1Fv2…Fvk+1\sum\limits_{v_1+v_2+\ldots+v_{k+1}=n-k}F_{v_1}F_{v_2}\ldots F_{v_{k+1}}v1+v2+…+vk+1=n−k∑Fv1Fv2…Fvk+1。

然后考虑怎么把 k+1k+1k+1 个块用 kkk 个配对连起来。第 iii 个块有 2vi+12v_i+12vi+1 个地方可以用来连接其他块，若其挂了 cic_ici 个子块则方案数就是 (2vi+cic)i\binom{2v_i+c_i}c_i(c2vi+ci)i，整个结构有 kkk 个连接因此必有 c1+c2+…+ck+1=kc_1+c_2+\ldots+c_{k+1}=kc1+c2+…+ck+1=k，求和得到总连接方法数为 ∑c1+c2+…+ck+1=k∏i=1k+1(2vi+cici)\sum\limits_{c_1+c_2+\ldots+c_{k+1}=k}\prod\limits_{i=1}^{k+1}\binom{2v_i+c_i}{c_i}c1+c2+…+ck+1=k∑i=1∏k+1(ci2vi+ci)，换元一下然后直接上 ex-Vandermonde 可得上式的值为 (2n−k+1+k−1k)=(2nk)\binom{2n-k+1+k-1}k=\binom{2n}k(k2n−k+1+k−1)=(k2n)。

然后考虑每个点的儿子数量分别为 c1,c2,…,ck+1c_1,c_2,\ldots,c_{k+1}c1,c2,…,ck+1，考虑到 c1+c2+…+ck+1=kc_1+c_2+\ldots+c_{k+1}=kc1+c2+…+ck+1=k 因此套路的把每个 cic_ici 的值都减 111，此时 ∑ci=−1\sum c_i=-1∑ci=−1。一个树按照 DFS 顺序访问这些结点的时候需要满足最后一个点钱已经出现的儿子总数始终不少于已经用掉的点数。考虑下面给出的引理：

:::info循环引理对一个总和为 −1-1−1 的序列，其所有循环移位中恰有一个移位满足上面给出的树的条件。

Reference. :::

所以同一种儿子数加上连接方法从 k+1k+1k+1 个不同的位置开始看必然恰好只有一个是真正合法的有根树。因此 (2nk)\binom {2n}k(k2n) 种方法中合法方案占比只有 1k+1\frac1{k+1}k+11，最终结果就是 (2nk)k+1\frac{\binom{2n}k}{k+1}k+1(k2n)。 ::::

namespace lowspeed_song {

mt19937_64 mt(time(0));

int fac[N], inv[N], ifac[N];

inline void init() {
}

int a[N], b[N], res[N], f[510][510];

inline void sol([[maybe_unused]]int __testcase_id, [[maybe_unused]]int __testcase_sum) {
    int n, mod; cin >> n >> mod;
    fac[0] = inv[0] = ifac[0] = 1;
    fac[1] = inv[1] = ifac[1] = 1;
    for (int i = 2; i < N; ++i) {
        fac[i] = fac[i - 1] * i % mod;
        inv[i] = mod - inv[mod % i] * (mod / i) % mod;
        ifac[i] = ifac[i - 1] * inv[i] % mod;
    } memset(f, 0, sizeof f);
    function<int(int, int)> binom = [&](int a, int b) { return fac[a] * ifac[b] % mod * ifac[a - b] % mod; };
    function<int(int, int)> calc = [&](int n, int k) { return binom(n, k) * inv[k + 1] % mod; };
    for (int i = 0; i <= n; ++i) f[0][i] = calc(i + i, i) * calc(i + i, i) % mod;
    for (int i = 1; i <= n; ++i) for (int j = 0; j <= n; ++j) for (int k = 0; k <= n - j; ++k)
        f[i][j + k] = (f[i][j + k] + f[i - 1][j] * f[0][k] % mod) % mod;
    for (int i = 0; i <= n; ++i) res[i] = calc(n + n, i) * f[i][n - i] % mod;
    for (int i = n - 1; ~i; --i) for (int j = i + 1; j <= n; ++j) res[i] = (res[i] + mod - res[j] * binom(j, i) % mod) % mod;
    for (int i = 0; i <= n; ++i) cout << res[i] << ' '; cout << '\n';
}

} // namespace lowspeed_song

CF2246F Whoname and Unsorted Array 题解

Sun, 06 Sep 2026 03:31:52 GMT

先找操作的不变量，套路的想到操作前后逆序对奇偶性的变化，在 iii 位置进行一次操作会产生 n−2n-2n−2 次交换，而逆序对奇偶性和交换次数奇偶性是相同的，因此若 nnn 初始为偶数则序列的逆序对数永远不会变化，此时若初始逆序对数量为奇数则必然无解。

然后考虑增量构造，每次在数组中维护一个有序的后缀。设当前的后缀为 1,2,3,…,i−11,2,3,\ldots,i-11,2,3,…,i−1 要把 iii 移动到序列的最后面，则考虑先在数组中找到 iii 出现的位置 pospospos。此时若 pos>1pos>1pos>1 则容易想到直接对 pos−1pos-1pos−1 位置执行一次操作就可以在不影响 1,2,3,…,i−11,2,3,\ldots,i-11,2,3,…,i−1 的前提下把 iii 扔到数组最后面。而如果 pos=1pos=1pos=1 则需要单独处理，手玩一下发现可以对 2,1,n−12,1,n-12,1,n−1 三个位置依次进行一次操作，就可以在不影响 1,2,3,…,i−11,2,3,\ldots,i-11,2,3,…,i−1 的前提下把 iii 扔到数组的最后面。因此直接枚举 i=1,2,3,…,n−2i=1,2,3,\ldots,n-2i=1,2,3,…,n−2 就可以把除了 n−1n-1n−1 和 nnn 以外的所有元素都正确归位。最后数组只剩下两种不同的情况：

[n−1,n,1,2,3,…,n−2][n-1,n,1,2,3,\ldots,n-2][n−1,n,1,2,3,…,n−2]。
[n,n−1,1,2,3,…,n−2][n,n-1,1,2,3,\ldots,n-2][n,n−1,1,2,3,…,n−2]。

考虑分别处理这两种情况。第二种情况考虑先对 111 执行一次操作把序列变为 [n−1,1,2,3,…,n−2,n][n-1,1,2,3,\ldots,n-2,n][n−1,1,2,3,…,n−2,n] 然后再连续对 222 位置执行 n−2n-2n−2 次操作最后再对 111 执行一次操作就可以让整个数组有序。而第一类情况有一个特别简单的构造方法就是依次对 2,1,n−1,12,1,n-1,12,1,n−1,1 四个位置分别执行一次操作就可以让整个数组变得有序。

操作次数显然不超过 4n4n4n。因为 nnn 很小所以直接暴力模拟 O(n2)O(n^2)O(n2) 就可以通过该题。

namespace lowspeed_song {

inline void init() {
}

mt19937 mt(time(0));

int a[N], b[N];

inline void sol([[maybe_unused]]int __testcase_id, [[maybe_unused]]int __testcase_sum) {
    int n; cin >> n;
    for (int i : views::iota(1, n + 1))
        cin >> a[i];
    vector<int> ops;
    function<void(int)> op = [&](int pos) -> void {
        assert(1 <= pos && pos <= n);
        copy(a + 1, a + n + 1, b + 1);
        a[1] = b[pos], a[n] = b[pos + 1];
        for (int i : views::iota(1, pos))
            a[i + 1] = b[i];
        for (int i : views::iota(pos + 2, n + 1))
            a[i - 1] = b[i];
        ops.emplace_back(pos);
        assert(ops.size() <= 4 * n);
    };
    function<int()> calc_inv = [&]() {
        int cnt = 0;
        for (int i : views::iota(1, n))
            for (int j : views::iota(i + 1, n + 1))
                if (a[j] < a[i])
                    ++cnt;
        return cnt;
    };
    cerr << "inverse = " << calc_inv() << '\n';
    if (n % 2 == 0 && calc_inv() % 2) {
        cout << -1 << '\n';
        return;
    }
    for (int i : views::iota(1, n - 1)) {
        int pos = -1;
        for (int j : views::iota(1, n + 1))
            if (a[j] == i) {
                pos = j;
                break;
            }
        if (pos == 1)
            op(2), op(1), op(n - 1);
        else
            op(pos - 1);
    }
    if (n != 2) {
        if (a[1] == n - 1) {
            // [n - 1, n, 1, 2, ..., n - 2]
            op(2);
            op(1);
            op(n - 1);
            op(1);
        } else {
            // [n, n - 1, 1, 2, ..., n - 2]
            op(1);
            for (int i : views::iota(0, n - 2))
                op(2);
            op(1);
        }
    }
    cout << ops.size() << '\n';
    for (int &i : ops)
        cout << i << ' ';
    cout << '\n';
}

} // namespace lowspeed_song

CF2248F Matrix Elimination 题解

Sun, 06 Sep 2026 02:19:42 GMT

先考虑 n,m≥2n,m\ge 2n,m≥2 的情况。此时记第 iii 行内所有元素的和为 RiR_iRi，第 jjj 列内所有元素的和为 CjC_jCj。则一个位置 (i,j)(i,j)(i,j) 是合法的当且仅当 ai,j≥(Ri−ai,j)+(Cj−ai,j)a_{i,j}\ge (R_i-a_{i,j})+(C_j-a_{i,j})ai,j≥(Ri−ai,j)+(Cj−ai,j) 即 Ri+Cj−3ai,j≤0R_i+C_j-3a_{i,j}\le 0Ri+Cj−3ai,j≤0。然后考虑当前操作选了个 x×yx\times yx×y 的子矩形，则对该子矩形内的每个点 (i,j)(i,j)(i,j)，RiR_iRi 都会减少 yyy，CjC_jCj 都会减少 xxx，ai,ja_{i,j}ai,j 都会减少 111，因此 Ri+Cj−3ai,jR_i+C_j-3a_{i,j}Ri+Cj−3ai,j 的值必然减少 x+y−3x+y-3x+y−3。为了更快的减少 Ri+Cj−3ai,jR_i+C_j-3a_{i,j}Ri+Cj−3ai,j 的值，很显然希望每次减少的量尽量多，因此每次直接减去整个矩阵必然是最优情况。此时每个格子变成峰值所需要的次数就是 max⁡(0,⌈Ri+Cj−3ai,jn+m−3⌉)\max(0,\lceil\frac{R_i+C_j-3a_{i,j}}{n+m-3}\rceil)max(0,⌈n+m−3Ri+Cj−3ai,j⌉)，排序取第 kkk 小即可。

然后考虑 min⁡(n,m)=1\min(n,m)=1min(n,m)=1 的情况，为了方便这里只讨论 n=1n=1n=1，问题变为一个长度为 mmm 的数组 aaa，记 aaa 数组所有元素的和为 SSS，则峰值条件就是 ai≥S−aia_i\ge S-a_iai≥S−ai 即 S−2ai≤0S-2a_i\le 0S−2ai≤0。对一个长度为 kkk 的连续区间做操作，则一个位置 iii 如果在操作区间中则 S−2aiS-2a_iS−2ai 会减少 m−2m-2m−2，否则 S−2aiS-2a_iS−2ai 会减少 mmm。容易证明此时操作长度不超过 n−2n-2n−2 的区间一定不如直接对整个数组整体操作，因此有效的操作区间只有 [1,m],[1,m−1],[2,m][1,m],[1,m-1],[2,m][1,m],[1,m−1],[2,m] 三个。此时还可以发现不能同时执行区间 [1,m−1][1,m-1][1,m−1] 和 [2,m][2,m][2,m]，否则把这两次操作都换成对 [1,m][1,m][1,m] 执行一定不会让结果更差。因此直接分类讨论可能执行的另一个区间是 [1,m−1][1,m-1][1,m−1] 还是 [2,m][2,m][2,m] 然后解不等式组即可，解不等式组部分是 boring 的 dirty work，这里就不再展开赘述了，细节可以看代码实现。

namespace lowspeed_song {

inline void init() {
}

mt19937 mt(time(0));

inline void sol([[maybe_unused]]int __testcase_id, [[maybe_unused]]int __testcase_sum) {
    int n, m, k;
    cin >> n >> m >> k;
    vector<vector<int>> a(n, vector<int>(m, 0));
    for (int i : views::iota(0, n))
        for (int j : views::iota(0, m))
            cin >> a[i][j];
    function<int(int, int)> calc = [&](int a, int b) {
        a = max<int>(a, 0);
        return (a + b - 1) / b;
    };
    if (n > 1 && m > 1) {
        vector<int> R(n, 0), C(m, 0);
        for (int i : views::iota(0, n))
            for (int j : views::iota(0, m))
                R[i] += a[i][j], C[j] += a[i][j];
        vector<int> cand;
        for (int i : views::iota(0, n))
            for (int j : views::iota(0, m))
                cand.emplace_back(max<int>(0, calc(R[i] + C[j] - 3 * a[i][j], n + m - 3)));
        sort(cand.begin(), cand.end());
        cout << cand[k - 1] << '\n';
    } else {
        vector<int> a_1d;
        for (int i : views::iota(0, n))
            for (int j : views::iota(0, m))
                a_1d.emplace_back(a[i][j]);
        function<int(vector<int>, int)> solve = [&](vector<int> a_1d, int k) -> int {
            int n = a_1d.size();
            if (n == 1)
                return a_1d[0] >= 0 ? 0 : -1;
            if (n == 2)
                return (k == 1) ? 0 : abs(a_1d[0] - a_1d[1]);
            int sum = accumulate(a_1d.begin(), a_1d.end(), 0ll);
            vector<int> b = a_1d;
            sort(b.begin(), b.end(), greater<>());
            int res = calc(sum - 2 * b[k - 1], n - 2);
            function<int(int)> calc_inner = [&](int p) -> int {
                if (k == 1)
                    return calc(sum - 2 * p, n - 1);
                int pos = lower_bound(b.begin(), b.end(), p, greater<>()) - b.begin();
                int q = (pos < k - 1) ? b[k - 1] : b[k - 2];
                return max({
                    calc(sum - 2 * p, n - 1), 
                    calc(sum - 2 * q, n - 2), 
                    calc(sum - p - q, n - 2)
                });
            };
            res = min({
                res, 
                calc_inner(a_1d[0]), 
                calc_inner(a_1d.back())
            });
            return res;
        };
        cout << solve(a_1d, k) << '\n';
    }
}

} // namespace lowspeed_song

0103abc 的网站

AGC047E Product Simulation 题解

AGC041C Domino Quality 题解

P17781 千早爱音不是罪过 题解

新的一篇

从这里开始

Records

P17802 [CXOI2026] 想要变成鹰的鱼 题解

P17801 [CXOI2026] 大潘小潘向前 p 题解

P17800 [CXOI R7-D] 使一颗心不免哀伤 题解

sol 1

sol 2

n≤10n\le 10n≤10

n≤2000n\le 2000n≤2000

一些简单的无解情况

n≤6n\le 6n≤6

2∤n2\nmid n2∤n 且 x=0x=0x=0

2∣n2\mid n2∣n 且 x=nx=nx=n

2∤n2\nmid n2∤n 且 x=1x=1x=1

2∣n2\mid n2∣n 且 x=n+1x=n+1x=n+1

n=2k,k∈N+n=2^k,k\in\mathbb{N_+}n=2k,k∈N+​

2∣n2\mid n2∣n

2∤n2\nmid n2∤n 且 x≤nx\le nx≤n

2∤n2\nmid n2∤n 且 n<x<2high(n)n<x<2high(n)n<x<2high(n)

时间复杂度

Sol 3

构造

按 n mod 4n\bmod 4nmod4 初始化

二进制贪心分组

CORNER CASE

无解判定

Code Golf!

P17798 [CXOI R7-B2] 晴涵梦（Hard Version） 题解

P17796 [CXOI R7-A] 追忆岁月 题解

最小值

最大值

P17797 [CXOI R7-B1] 晴涵梦（Easy Version） 题解

为什么全程使用 __int128 计算不会导致答案溢出？

P3838 [IOI 2017] Toy Train 题解

P14238 [CCPC 2024 Shandong I] 三角形 题解

A=B≥CA=B\ge CA=B≥C

A>B,CA>B,CA>B,C

P15942 [JOI Final 2026] 赌场 / Casino 题解

P13184 [GCJ 2017 Finals] Teleporters 题解

P17571 「FAOI-R(-2)」数列计数 2024 题解

P17618 [Math+Girl×1] dancing With Myself in the sunset / Wheels Mst 题解

i<ni<ni<n

i=ni=ni=n

CF2262E Paired Bracket Sequences 题解

CF2246F Whoname and Unsorted Array 题解

CF2248F Matrix Elimination 题解

P17781 千早爱音不是罪过题解

P17802 [CXOI2026] 想要变成鹰的鱼题解

P17800 [CXOI R7-D] 使一颗心不免哀伤题解

n=2k,k∈N+n=2^k,k\in\mathbb{N_+}n=2k,k∈N+

P17798 [CXOI R7-B2] 晴涵梦（Hard Version）题解

P17796 [CXOI R7-A] 追忆岁月题解

P17797 [CXOI R7-B1] 晴涵梦（Easy Version）题解

为什么全程使用 `__int128` 计算不会导致答案溢出？

P14238 [CCPC 2024 Shandong I] 三角形题解