XianRui's Blog

Template of Aho-Corasick AutoMaton

Mon, 06 Apr 2026 22:14:49 GMT

I learned Ownner Pointer and Reference Pointer today, and use them to write a safe template of ACAM.

The process of algorithm is needless to say.

template <typename Tp>
using OwnPointer = std::unique_ptr<Tp>;
template <typename Tp>
using RefPointer = Tp*;

constexpr int MAXN = 6;
constexpr int ALPHABET = 26;

class ACAM {
public:
    explicit ACAM(const std::vector<std::string>& set) {
        Build(set);
    }
private:
    struct TrieNode {
        std::array<RefPointer<TrieNode>, ALPHABET> ch;
        RefPointer<TrieNode> fail;
        bool is_taboo;

        TrieNode() {
            ch.fill(nullptr);
            fail = nullptr;
            is_taboo = false;
        }
    };
    std::vector<OwnPointer<TrieNode>> node_pool;
    RefPointer<TrieNode> root;

    RefPointer<TrieNode> NewNode() {
        node_pool.emplace_back(std::make_unique<TrieNode>());
        return node_pool.back().get();
    }

    void Insert(const std::string& s) {
        RefPointer<TrieNode> now = root;
        for(const char& c : s) {
            int id = c-'a';
            if(!now->ch[id]) {
                now->ch[id] = NewNode();
            }
            now=now->ch[id];
        }
        now->is_taboo = true;
    }

    void Build(const std::vector<std::string>& set) {
        root = NewNode();
        for(const std::string &s : set) Insert(s);
        std::queue<RefPointer<TrieNode>> q;
        root->fail = root;
        for(int i=0;i<ALPHABET;i++) {
            if(root->ch[i]) {
                root->ch[i]->fail = root;
                q.push(root->ch[i]);
            } else root->ch[i] = root;
        }
        while(!q.empty()) {
            auto u = q.front(); q.pop();
            u->is_taboo |= u->fail->is_taboo;
            for(int i{0}; i < ALPHABET; i++) {
                if(u->ch[i]) {
                    u->ch[i]->fail = u->fail->ch[i];
                    q.push(u->ch[i]);
                } else u->ch[i] = u->fail->ch[i];
            }
        }
    }
public:
    auto Root() const -> RefPointer<TrieNode> {
        return root;
    }
    auto Next(RefPointer<TrieNode> u, char c) const -> RefPointer<TrieNode> {
        return u->ch[c-'a'];
    }
    auto IsTaboo(RefPointer<TrieNode> u) const -> bool {
        return u->is_taboo;
    }
    auto Size() const -> int {
        return node_pool.size();
    }
};

~~Remember that u are solving LuoguP4569 that time, Taboo means unallowed string.~~

Solution Report of String(Easy) Topic

Thu, 26 Mar 2026 19:38:13 GMT

LuoguP13270 最小表示法

Useful Link
Problem Statement
Reference Blog

Hash Tech: How to compare string with dictionary order

Hash & Binary Lifting find the LCP of two string and then compare the next character.

std::string s, t;
int len{0};
for (int k{19}; k >= 0; k--) {
    if (getHash(s, 0, len+(1<<k)-1) == getHash(t, 0, len+(1<<k)-1)) {
        len += (1 << k);
    }
}
if (len == std::min(s.size(), t.size())) ; // s == t
else ; // s[len] < t[len]

*above code could be wrong

Solution

It's difficult to solve a problem on circle so copy string behind it.

Now we should solve below problem:
Find $i$ hold $\min s[i\dots i+n-1]$

Then we consider how to check it quickly. When we are checking the cyclic isomorphism start with $st$ and $i$.

First we find the maximum $j$ hold $s[st\dots st+j-1] = s[i\dots i+j-1]$.
Then compare the character $s[st+j]$ and $s[i+j]$.
- if $s[st+j]$ is better than $s[i+j]$, all string start with $i \le k \le i+j-1$ cannot be answer.
- otherwise, move $i$ to $\max(st+j+1, i+1)$.

#include<bits/stdc++.h>
using namespace std;
const int maxn=2e7;
int n;
string s;
int main() {
	ios::sync_with_stdio(0);
	cin.tie(0),cout.tie(0);
	cin>>n>>s,s=" "+s+s;
	int st=1;
	for(int i=2;i<=n;){
		int j=0;
		for(j=0;j<n && s[st+j]==s[i+j];j++);
		if(j==n) break;
		if(s[st+j]>s[i+j]){
            int m=st;
            st=i,i=max(i+1,m+j+1);
        }
		else i+=j+1;
	}
	for(int i=st;i<=st+n-1;i++) cout<<s[i];
	return 0;
}

LuoguP9873 [EC Final 2021] Beautiful String

Useful Link
Problem Statement
Reference Blog

We found that beautiful string is of the form AABCAB, so we can calculate answer by count AB.

Then we can define below two array:

Let $f[i][j]$ denote, when AB $= S[i\dots i + j − 1]$, the number of substrings equal to AB that start after position $i + j$.
Let $g[i][j]$ denote, when AB $= S[i\dots i + j − 1]$, the number of substrings before AB that are prefixes of AB.

Then the answer is $\sum f[i][j]\times g[i][j]$.

Now consider how to calculate these array.

For $f$, calculate the LCP length of all pair of $s[i\dots n]$ and $s[j\dots n]$ then save them in $f[i][LCP]$, suffixing f.
For $g$, count the number of LCP of $s[i\dots n]$ and $s[i-j\dots n]$ which length is greater than $j$.

cin >> S;
n = S.length(); S = ' ' + S;
for(int i = n; i; i--)
    for(int j = i; j <= n; j++)
        if(S[i] == S[j])
            lcp[i][j] = lcp[i + 1][j + 1] + 1;
for(int i = 2; i <= n; i++)
    for(int j = i + 3; j < n; j++) {
        int k = min(j - i - 1, lcp[i][j]);
        if(k >= 2) f[i][k]++;
    }
for(int i = 2; i <= n; i++)
    for(int j = n - 1; j > 1; j--) f[i][j] += f[i][j + 1];
for(int i = 2; i <= n; i++)
    for(int j = 1; j <= min(i - 1, n - i + 1); j++) 
        if(lcp[i - j][i] >= j) g[i][j]++;
for(int i = 1; i <= n; i++)
    for(int j = 1; j <= n; j++) g[i][j] += g[i][j - 1];
long long ans = 0;
for(int i = 2; i <= n; i++)
    for(int j = 2; j <= n; j++) ans += 1ll * f[i][j] * g[i][j - 1];
cout << ans << '\n';

LuoguP9016 [USACO23JAN] Find and Replace G

These kind of question which after operation can cover early operation we can all consider it from back to front.

We can build a DAG to solve this question. Use examples as demonstrations.

a ab
a bc
c de
b bbb

Build 5 nodes for letter a to e, then build graph from last operation.

      (7,#,sz=3)
       /      \
 (6,#,2)      (2,'b')
   /    \
(2,'b') (2,'b')

Keep the structure of 2-branch tree, but reuse same node.

Below is operator c de:

   (8,#,2)
   /    \
(4,'d')(5,'e')

Then we can see how to combine two subtree (operator a bc):

           (9,#,5)
          /       \
     (7,#,3)    (8,#,2)
      /   \      /    \
  (6,#)    b    d      e
   / \
  b   b

Final version:

                    (10,#,8)
                   /        \
             (9,#,5)      (7,#,3)
            /      \      /      \
       (7,#,3)  (8,#,2) (6,#)    b
        /   \    /   \   /  \
    (6,#)   b   d     e b    b
     / \
    b   b

Then we can get answer from the tree size.

LuoguP7114 [NOIP2020] 字符串匹配

Useful Link
Problem Statement
Reference Blog

It's a really perfect tutorial. I don't even know what else to supplement.

We define the $i$-th element of Z-array denote the length of LCP of $s[0\dots n-1]$ and $s[i\dots n-1]$.

From the image we can know that $K$ in problem statement can take any integer from $1$ to $$ \left\lfloor\frac{z[i]}{i}\right\rfloor + 1 $$

$i$ is the length of cyclic section. You can understand this expression by the example image. Red part equal to Orange part and Orange part equal to Orange part. Similarly find Red, Orange and Green part are all equal so $3$ is the length of cyclic section.

Then we need focus on the number of each letter appear. Classify and discuss the parity of $K$. Define function $f(i,j)$ denote the number of letter wich appear odd times in $s[i\dots j]$. Let $t$ denote all value selection scheme for $K$, the scheme for $K$ to be a odd number should be $todd = t - t/2$, for even number should be $teven = t/2$.

When $K$ is an odd, we should find the number of $j\ (j\le i)$ which satisfy $f(0,j) \le f(i,n-1)$ is denoted as $t1$, it will provide $todd \times t1$ contribution.
When $K$ is an even, we should find the number of $j\ (j\le i)$ which satisfy $f(0,j) \le f(0,n-1)$ is denoted as $t2$, that is because the number of cyclic section is even, even if the letter appear for odd times, it finally turned to even times. So the letter which appear odd time equal to whole string. Answer will increase $teven \times t2$.

LuoguP3167 [CQOI2014] 通配符匹配

Useful Link
Problem Statement
Reference Blog

OK this problem can protrude the charm of DFS. Most of turorial are using difficult algorithm such as KMP, ACAM but forget the most easy algorithm.

#include<bits/stdc++.h>
using namespace std;
char ch[100001],wzc[100001];
int n;

bool _doudou(int x,int y)// Start brute-force search, search from back to front to avoid some tricky test cases, also makes implementation easier
{
    if(y==0)// If the pattern string is fully matched
    {
        if(x==0)return 1;// If the wildcard string is also fully consumed, then it's definitely correct
        for(int i=x;i>0;i--)// Check remaining '*' characters
            if(ch[i]!='*')return 0;// If anything other than '*', then it fails
        return 1;// Otherwise it's fine
    }

    if(!x)return 0;// If the wildcard string finishes first, then it must fail

    if(ch[x]=='*')// If we encounter a '*'
    {
        for(int i=y;i>=0;i--)// Try matching from all remaining positions.
                             // The time complexity looks high, but in practice most branches terminate quickly.
            if(_doudou(x-1,i))return 1;
    }
    else
    {
        if(wzc[y]==ch[x]||ch[x]=='?')
            return _doudou(x-1,y-1);// If it's '?', move both strings one position forward
        else return 0;// Match failed
    }
}

int main()
{
    scanf("%s%d",ch+1,&n);
    int len=strlen(ch+1);

    while(n--)
    {
        scanf("%s",wzc+1);

        if(_doudou(len,strlen(wzc+1)))
            printf("YES\n");
        else
            printf("NO\n");
    }

    return 0;
}

LuoguP3082 [USACO13MAR] Necklace G

Useful Link
Problem Statement
Reference Blog

This is a problem which using KMP to optmize DP.

Let $f_{i,j}$ denotes, the maximum we can keep when the first $i$-th letter of $a$ map the first $j$-th letter of $b$ exactly. Then we can get a easy transition

$$ f_{i+1,k} = \max{f_{i+1,k} ,f_{i,j}+1} $$

Then we should consider how to calculate $k$ quickly. Let $g_{i,j}$ denotes $k$ when map the first $i$-th letter of $b$ exactly and then next letter is $j$. Then we can get below transition.

$$ g_{i,j} = \begin{cases} i+1 & b[i+1] == j\ g_{nxt_{i}, j} & \operatorname{otherwise.} \end{cases} $$

Coding is easy.

Memo of Trigonometric Formula

Sun, 22 Mar 2026 20:01:23 GMT

This is a memo. To prevent me from forgetting some trigonometric formulas.

Basic Formula

Unit circle

Pythagorean Theotheorm

$$ \cos^2 \theta + \sin^2 \theta = 1 $$

Rotate matrix (counterclockwise rotation)

$$ \left [ \begin{matrix} \cos\theta & -\sin\theta \ \sin\theta & \cos\theta \end{matrix} \right ] \times \left [ \begin{matrix} x \ y \end{matrix} \right ] $$

Sum Formula

$$ \begin{aligned} & \sin(\alpha + \beta) = \sin\alpha\cos\beta + \cos\alpha\sin\beta\ & \cos(\alpha + \beta) = \cos\alpha\cos\beta - \sin\alpha\sin\beta\ & \tan(\alpha + \beta) = \frac{\tan\alpha + \tan\beta}{1-\tan\alpha\tan\beta} \end{aligned} $$

Double and Half Formula

Double-angle

For sin.

$$ \sin 2\theta = 2\sin\theta\cos\theta $$

For cos.

$$ \begin{aligned} \cos 2\theta &= \cos^2\theta - \sin^2\theta \ &= 1 - 2\sin^2\theta\ &= 2\cos^2\theta -1 \end{aligned} $$

For tan.

$$ \tan 2\theta = \frac{2\tan\theta}{1-\tan^2\theta} $$

Half-angle

For sin & cos.

$$ \begin{aligned} \sin \frac{\theta}{2} &= \pm \sqrt{\frac{1-\cos\theta}{2}} \ \cos \frac{\theta}{2} &= \pm \sqrt{\frac{1+\cos\theta}{2}} \end{aligned} $$

For tan.

$$ \begin{aligned} \tan \frac{\theta}{2} &= \frac{\sin\theta}{1 + \cos\theta}\ &= \frac{1 - \cos\theta}{\sin\theta}\ &= \pm \sqrt{\frac{1-\cos\theta}{1+\cos\theta}} \end{aligned} $$

The sign is depend on which quardrant $\theta/2$ is in.

Also, there are some other trigonometric identities but they all can be prove by above formula so it's all for this memo.

Mobius Inversion

Mon, 09 Feb 2026 10:42:13 GMT

Introduction

Inversion is a common tool to solve some math problem.

This passage will introduce some trick for solving these problem.

Prerequisites

Multiplicative Functions

A function $f(n)$ is multiplicative if, for all $a,b$ with $\gcd(a,b)=1$, it satisfies $f(ab)=f(a)f(b)$. In particular, if this holds for all $a,b$, then the function is called completely multiplicative.

Common multiplicative functions:

Identity function: $\epsilon(n) = [n=1]$, complete
Constant function: $\operatorname{1}(n) = 1$, complete
Equality function: $\operatorname{id}(n) = n$, $\operatorname{id}_{k}(n)=n^k$, complete
Euler function: $\varphi(n) = \sum_{i=1}^{n}[\operatorname{gcd}(i,n)=1]$
Mobius function: $$ \mu(n)=\begin{cases} 1 & n=1\ 0 & \exists\ d\ \operatorname{satisfy\ that}\ d^2 | n\ (-1)^k & k\ \operatorname{denote\ quantity\ of\ distinct\ prime\ divisors} \end{cases} $$
Number of divisors function: $\operatorname{d}(n) = \sum_{d|n}1$
Sum of divisors function: $\sigma(n) = \sum_{d|n}d$

Dirichlet Convolution

Below is the formula of Dirichlet convolution: $$ (f\ast g)(n) = \sum_{d|n} f(d)g(\frac{n}{d}) $$

Dirichlet convolution satisfy below law:

Commutative law : $f\ast g = g\ast f$;
Associative law : $(f\ast g)\ast h = f\ast (g\ast h)$;
Distributive law : $f\ast (g+h) = f\ast g + f\ast h$;
Identity element : $f\ast\epsilon = f$.

And below is some important dirichlet convolution:

$\epsilon =\mu\ast 1$
$\operatorname{id} = \varphi\ast 1$
$\operatorname{d}=1\ast 1$
$\sigma = \operatorname{id}\ast 1$

The proof of these equation isn't difficult but very important, must try to prove them before reading below part.

Mobius Inversion

The following is the basic form of mobius inversion:

If $$ F(n) = \sum_{d|n}f(d), $$ then $$ f(n) = \sum_{d|n}\mu(d)F\left(\frac{n}{d}\right). $$

These relative explain "Inversion" perfectly: using Mobius function to get calculation method from $F(n)$ to $f(n)$ by the calculation method from $f(n)$ to $F(n)$.

And we can using below formula to prove these parttern easily.

Observe the form of the relation from $f(d)$ we can using Dirichlet Convolution to express it: $$ \begin{aligned} f &= f \ast \epsilon\ &= f \ast \mu \ast 1 \ &= f \ast 1 \ast \mu \ &= F \ast \mu \ &= \mu \ast F \ \end{aligned} $$

I will explain each step of this proof.

Dirichelet Convolution's law: identity element $\epsilon$
$\epsilon = \mu \ast 1$
Commutative law
The relative from $f(n)$ to $F(n)$ : $F = f \ast 1$
Commutative law

Mobius Inversion also have another form, this form is base on multiple.

$$ F(n)=\sum_{n|d}f(d), $$

then

$$ f(n)=\sum_{n|d}\mu\left(\frac{d}{n}\right)F(d). $$

This form cannot prove elegantly like before.

We can expand $F(d)$ in the formula after inversion

$$ f(n)=\sum_{n|d}\mu\left(\frac{d}{n}\right)\sum_{d|e}f(e). $$

Then swap summation:

$$ f(n) = \sum_{n|e} f(e) \sum_{n | d | e} \mu\left(\frac{d}{n}\right). $$

Then we define $d = nt, e = ns$ then this equation change to:

$$ f(n) = \sum_{s\ge 1} f(ns)\sum_{t|s}\mu(t) $$

As we know, because of the natrue of mobius function:

$$ \sum_{t|s}\mu(t) = \begin{cases} 1 & s = 1\ 0 & s > 1 \end{cases} $$

So that equation just can get result when $s = 1$, so the equation change to $f(n) = f(n)$, we finish the proof of multiple form of mobius inversion.

Classic Problem

Before solve some question, we need know a core trick.

$$ [\gcd(i,j)=1]=\sum_{d|\gcd(i,j)}\mu(d) $$

This trick even no need to prove. I already say mobius function have a natrue that the sum of the Mobius functions of the divisors of a number equal to 1 only when that number equal to 1.

Problem 1

$$ \sum_{i=1}^n\sum_{j=1}^m[\gcd(i,j) = k] $$

Solution:

$$ \begin{aligned} \sum_{i=1}^n\sum_{j=1}^m[\gcd(i,j) = k] &=\sum_{i=1}^{\lfloor n/k\rfloor}\sum_{j=1}^{\lfloor m/k\rfloor}[\gcd(i,j)=1]\ &=\sum_{i=1}^{\lfloor n/k\rfloor}\sum_{j=1}^{\lfloor m/k\rfloor}\sum_{d|\gcd(i,j)}\mu(d)\ &=\sum_{d=1}^{\min(\lfloor n/k\rfloor,\lfloor m/k\rfloor)}\mu(d)\sum_{i=1}^{\lfloor n/k\rfloor}[d|i]\sum_{j=1}^{\lfloor m/k\rfloor}[d|j]\ &=\sum_{d=1}^{\min(\lfloor n/k\rfloor,\lfloor m/k\rfloor)}\mu(d)\left\lfloor\frac{n}{kd}\right\rfloor\left\lfloor\frac{m}{kd}\right\rfloor \end{aligned} $$

Problem 2

$$ \sum_{i=1}^n\sum_{j=1}^md(ij) $$

Function $d(n)$ is number of divisors function.

Core Lemma:

$$ d(ij)=\sum_{x|i}\sum_{y|j}[\gcd(x,y)=1] $$

Solution:

$$ \begin{aligned} \sum_{i=1}^n\sum_{j=1}^md(ij) &=\sum_{i=1}^n\sum_{j=1}^m\sum_{x|i}\sum_{y|j}[\gcd(x,y)=1]\ &=\sum_{i=1}^n\sum_{j=1}^m\sum_{x|i}\sum_{y|j}\sum_{d|\gcd(x,y)}\mu(d)\ &=\sum_{x=1}^n\sum_{y=1}^m\left\lfloor\frac{n}{x}\right\rfloor\left\lfloor\frac{m}{y}\right\rfloor\sum_{d|\gcd(x,y)}\mu(d)\ &=\sum_{d=1}^{\min(n, m)}\mu(d)\sum_{x=1}^n\sum_{y=1}^m\left\lfloor\frac{n}{x}\right\rfloor\left\lfloor\frac{m}{y}\right\rfloor[d|x][d|y]\ &=\sum_{d=1}^{\min(n, m)}\mu(d)\sum_{x=1}^n\left\lfloor\frac{n}{xd}\right\rfloor\sum_{y=1}^m\left\lfloor\frac{m}{yd}\right\rfloor \end{aligned} $$

Problem 3

$$ \sum_{i=1}^n\sum_{j=1}^n i\times j\times \gcd(i,j) $$

Solution:

$$ \begin{aligned} \sum_{i=1}^n\sum_{j=1}^n i\times j\times \gcd(i,j) &=\sum_{d=1}^nd\sum_{i=1}^n\sum_{j=1}^nij[\gcd(i,j)=1]\ &=\sum_{d=1}^nd^3\sum_{i=1}^{\lfloor n/d\rfloor}\sum_{j=1}^{\lfloor n/d\rfloor}ij[\gcd(i,j)=1]\ &=\sum_{d=1}^nd^3\sum_{i=1}^{\lfloor n/d\rfloor}\sum_{j=1}^{\lfloor n/d\rfloor}ij\sum_{k|\gcd(i,j)}\mu(k)\ &=\sum_{d=1}^nd^3\sum_{k=1}^{\lfloor n/d\rfloor}\mu(k)\sum_{i'=1}^{\lfloor n/(kd)\rfloor}(ki')\sum_{j'=1}^{\lfloor n/(kd)\rfloor}(kj')\ &=\sum_{d=1}^nd^3\sum_{k=1}^{\lfloor n/d\rfloor}\mu(k)k^2\sum_{i'=1}^{\lfloor n/(kd)\rfloor}i'\sum_{j'=1}^{\lfloor n/(kd)\rfloor}j'\ &=\sum_{d=1}^nd^3\sum_{k=1}^{\lfloor n/d\rfloor}\mu(k)k^2\sum_{i'=1}^{\lfloor n/(kd)\rfloor}i'\sum_{j'=1}^{\lfloor n/(kd)\rfloor}j'\ &=\sum_{d=1}^nd^3\sum_{k=1}^{\lfloor n/d\rfloor}\mu(k)k^2S\left(\left\lfloor\frac{n}{kd}\right\rfloor\right)^2 \end{aligned} $$

Problem 4

$$ \prod_{i=1}^n\prod_{j=1}^mf_{\gcd(i,j)} $$

Function $f(n)$ is Fibonacci sequence.

Core Lemma:

$$ f_{\gcd(i,j)}=\gcd(f_i, f_j) $$

Below is proof.

Lemma 1. $\gcd(f_n,f_{n-1})=1$

Prove it by mathematical induction:

Base case:
- For $n=1$, $\gcd(f_1, f_0) = \gcd(1, 0) = 1$
- For $n=2$, $\gcd(f_2, f_1) = \gcd(1, 1) = 1$
Inductive hypothesis: Assume it holds for $n = k$.
Inductive step: When $n = k+1$, $f_{k+1} = f_k + f_{k-1}$, so $\gcd(f_{k+1},f_k)=\gcd(f_k+f_{k-1},f_k)=\gcd(f_k,f_{k-1})=1$. (Becasue of $\gcd(x+y,y) = \gcd(x,y)$)

Lemma 2. When $m > n$, $\gcd(f_m,f_n)=\gcd(f_n, f_{m\bmod n})$ holds.

Before prove this lemma, we should know a law $f_{a+b}=f_{a+1}f_b + f_af_{b-1}$ Still use mathematical induction to prove it:

Base case: For $b = 1$, $f_{a+1}=f_{a+1}f_1 + f_af_0 = f_{a+1}$
Inductive hypothesis: Assume it holds when $b \le k$.
Inductive step: When $b = k+1$, $$ \begin{aligned} f_{a+k+1} &=f_{a+k} + f_{a+k-1}\ &=(f_{a+1}f_k + f_af_{k-1}) + (f_{a+1}f_{k-1} + f_af_{k-2})\ &=f_{a+1}(f_k+f_{k-1}) + f_{a}(f_{k-1}+f_{k-2})\ &=f_{a+1}f_{k+1}+f_{a}f_{k}. \end{aligned} $$

When try to prove Lemma 2.

Let $a=n,b=(q-1)n+r$, then $f_m = f_{qn+r} = f_{n+[(q-1)n+r]} = f_{n+1}f_{(q-1)n+r}+f_{n}f_{(q-1)n+r-1}$, So: $$ \gcd(f_m, f_n) = \gcd(f_{n+1}f_{(q-1)n+r}+f_nf_{(q-1)n+r-1}, f_n). $$

Because of $\gcd(x+ky, y) = \gcd(x, y)$, so we can simplify above expression to below one:

$$ \gcd(f_m, f_n) = \gcd(f_{n+1}f_{(q-1)n+r}, f_n). $$

Then becasue of Lemma 1, we can know that $\gcd(f_m, f_n) = \gcd(f_{(q-1)n+r}, f_n)$ (because there are no common divisior between $f_{n+1}$ and $f_n$), then repeat this process, we can found taht $\gcd(f_m, f_n) = \gcd(f_{m\bmod n}, f_n)$

Now we going to prove that core lemma.

Let $d = \gcd(i,j)$. By the Euclidean algorithm, $$ \gcd(i, j) = \gcd(j, i \bmod j) = \gcd(i \bmod j, j \bmod (i \bmod j)) = \dots = \gcd(d, 0) = d. $$

Combining Lemma 2, we can apply the same reduction process to $\gcd(f_i, f_j)$: $$ \gcd(f_i, f_j) = \gcd(f_j, f_{i \bmod j}) = \gcd(f_{i \bmod j}, f_{j \bmod (i \bmod j)}) = \dots = \gcd(f_d, f_0). $$

By definition, $f_0 = 0$, and $\gcd(f_d, 0) = f_d$ (the greatest common divisor of a non-zero number and $0$ is the number itself). Therefore, $$ \gcd(f_i, f_j) = f_d = f_{\gcd(i,j)}. $$

Solution:

$$ \begin{aligned} \prod_{i=1}^n\prod_{j=1}^mf_{\gcd(i,j)} &=\prod_{d=1}^{\min(n, m)}{f_d}^{\sum_{i=1}^n\sum_{j=1}^m[\gcd(i,j)=d]}\ &=\prod_{d=1}^{\min(n, m)}{f_d}^{\sum_{d|T}^{\lfloor n/k\rfloor}\mu(k)\lfloor\frac{n}{dk}\rfloor\lfloor\frac{m}{dk}\rfloor}\ &=\prod_{d=1}^{\min(n, m)}\prod_{d|T}{f_d}^{\mu(T/d)\lfloor n/T\rfloor\lfloor m/T\rfloor} \end{aligned} $$

The last step is because $a^{x+y} = a^xa^y$, we dismantle the sum.

Summarize

The core idea of mobius inversion is optmize the time complexity of a expression by the natrue of mobius function.

Virtual Tree

Fri, 06 Feb 2026 11:54:11 GMT

Introduction

As we know that there are some problem we need maintain some information on a sparse tree (When we describe a tree is "sparse", there are few key points).

Using this structure, some tree DP algorithms that depend on tree size can be proven correct.

Build Virtual Tree

We have two ways to build a tree.

sort twice.
monotonicity stack.

Sort Twice

This algrithm is easy to code but hard to understand, below is algorithm flow:

sort key node by dfn.
get LCA for each close node.
build virtual tree.

How to prove this algorithm?

If $x$ is an ancestor of $y$, then connect $x$ directly to $y$. Since the DFS order guarantees that the DFS orders of $x$ and $y$ are adjacent, there are no critical points on the path from $x$ to $y$.
If $x$ is not an ancestor of $y$, then consider $\operatorname{LCA}(x,y)$ as an ancestor of $y$. Based on the previous case, it can be proven that there are no critical points on the path from $\operatorname{LCA}(x,y)$ to $y$.

Therefore, connecting $\operatorname{LCA}(x,y)$ and $y$ will not result in any omissions or repetitions.

Furthermore, will the fact that the first node is not connected to any node have any impact? Since the first node is always the root of the tree, it will not have any impact, so the total number of edges is $m-1$.

Monotonicity Stack

This algorithm is maintaining a right chain of virtual tree.

Algorithm Flow:

push node $1$ (root) in stack.
sort the key node by dfs order.
check the LCA of stack top and now node.
pop stack top until dfs order of top is not greater than dfs order of LCA(top, now). we need add edge from new top to old top.
if dfn[top] == dfn[LCA(top, now)], LCA is already in stack add edge directly; if less than, add edge from LCA to old top, and push LCA in stack.
then repeat above process.

bool cmp(const int x, const int y) { return id[x] < id[y]; }

void build() {
    sort(h + 1, h + k + 1, cmp);
    sta[top = 1] = 1, g.sz = 0, g.head[1] = -1;
    // Push node 1 onto the stack, clear the adjacency list corresponding to node 1, and set the number of edges in the adjacency list to 0
    for (int i = 1, l; i <= k; ++i) {
        if (h[i] != 1) {
            // If node 1 is a key node, do not add it again
            l = lca(h[i], sta[top]);
            // Calculate the LCA between the current node and the top node of the stack
            if (l != sta[top]) {
                // If the LCA is different from the top element of the stack, it means that the current node is not on the chain stored in the current stack
                while (id[l] < id[sta[top - 1]]) {
                    // When the DFS order of the second largest node is greater than the DFS order of the LCA
                    g.push(sta[top - 1], sta[top]), top--;
                    // Connect the chains that do not overlap with the chain containing the current node and pop them
                }
                if (id[l] > id[sta[top - 1]]) {
                    // If the LCA is not equal to the second largest node (greater than or not equal to is essentially the same)
                    g.head[l] = -1, g.push(l, sta[top]), sta[top] = l;
                    // This indicates that the LCA is being pushed onto the stack for the first time. Clear its adjacency list, connect the edges, pop the top element from the stack, and push the LCA
                    // onto the stack
                } else {
                    g.push(l, sta[top--]);
                    // This indicates that the LCA is the second largest node. Pop the top element from the stack directly
                }
            }
            g.head[h[i]] = -1, sta[++top] = h[i];
            // The current node is necessarily the first one pushed onto the stack, clear the adjacency list and push it onto the stack
        }
    }
    for (int i = 1; i < top; ++i) {
        g.push(sta[i], sta[i + 1]); // Connect the last remaining chain
    }
    return ;
}

Summarize

Tricky. Aslo can be considered violence.

Solution Report of Construct Topic

Thu, 22 Jan 2026 15:54:20 GMT

Introduction

It's the problem list of 01/22/2026 class, about construct problem, that's a tricky part in OI, know we will see some.

A - QOJ-4913 子集匹配

Problem Statement

Transfer problem statement:

$L$: All subset which exactly have $K$ ones.
$R$: All subset which exactly have $K-1$ ones.
One edge from $S$ to $T$ equal to change a 1-node in $S$ to 0 then $S$ equal to $T$.
This problem require different $S$ cannot contact same $T$.

Construct Idea:

let 1 equal to add 1 and 0 equal to minus 1.
then find the max position $p$ of prefix sum.
flip 0&1 in position $p+1$.

Prove: Why it is a injection?

assumpted there is a $S'$ mapped same $T$ with $S$.
we can find that $T$ have $i,j$ places which $S$ or $S'$ is $1$ but now is $0$, so $T$ must have $K-2$ ones, it's not satisfy difinition of $T$, so this mapping must be a injection.

Good problem, it's take me 1 day to understand.

B - Adjacent Difference

Problem Statement

For this kind of construction problem, we can try to solve it using some special subtask.

If this matrix just have 0/1, and $d$ equal to $1$, how to modify it? It's not difficult to find that answer must be below form:

010  |  101
101  |  010
010  |  101

We can calculate answer in each situation, get the mininum. Then try to expand this special solution to whole problem. We can enumerate a $k$ then difine odd and even be below rules:

$$ \begin{aligned} \operatorname{odd}\ &: \ a \equiv k & \pmod{2d}\ \operatorname{even}\ &: \ a \equiv k+d & \pmod{2d} \end{aligned} $$

Using above solution, time complexity is $O(dn^2)$.

C - Make SYSU Great Again II

Problem Statement

We call the cell which:

$(i+j)\bmod 2 = 0$ is Black Cell.
$(i+j)\bmod 2 = 1$ is White Cell.

So we need promise the bitwise and value of each close Black and White cell equal to 0. Then we can start our constructing.

First we have below guess:

Assign unique number in Black Cell.
Then put avaliable number in White Cell.

We need find a way to calculate the number in cell quickly.

For black cell:

high bits = gray( (i + j) / 2 )
low  bits = gray( (i - j + (n-1)) / 2 )

value = (high << K) | low

You can proove that different cell $(i,j)$ map different gray code number.

Maybe four neighbors can generate at most 4 same number, and add one of black cell, at most 5 same number, statisfy the problem requirement.

D - Tournament Construction

Problem Statement

According to the Landau theorem, we sort the original sequence $a$ and define $f(i,j,y)$ as representing a graph of size $i$ with vertices $j$ and edges $y$.

According to the theorem, $y ≥ \frac{j(j−1)}{2}$ always holds true.

We enumerate $i,j,y$ and the state at $i−1$. If $f(i−1,k,x)$ is feasible, then $f(i,j,y)$ is also feasible.

We also record $j−k$ at this point.

This allows us to construct the original out-degree sequence.

Let the out-degree sequence established in step 1 be $d_i$, and the one established in step 2 be $u_i$. First, assume $\forall i>j$, and all edges are in the direction $i\rightarrow j$. Then $u_i = i−1$.

Each time, find a triple $(i,j,k)$ such that $u_i > d_i, u_j = d_j, u_k < d_k$, and there exist edges $i\rightarrow j$ and $j\rightarrow k$.

In this way, we can reverse these two edges, achieving the effect that $u_i \leftarrow u_i −1, u_j \leftarrow u_j, u_k \leftarrow u_k −1$.

By continuously repeating the above steps, u can gradually approach d, eventually becoming exactly the same.

E - LGP10441 [JOIST 2024] 乒乓球 / Table Tennis

Problem Statememt

We have a classic conclusion: the struction of tournament just depend on in-degree array, and triple circle will add one more when we change a pair $(x,x+2)$ to $(x+1,x+1)$.

So we can use this to construct it.

Find the smallest $n_0$ which can statisfy the maximum triple circle less than $m$, then change the triple circle quantity on it.

Fast Mobius Transform and Fast Walsh-Hadamard Transform

Thu, 22 Jan 2026 10:39:18 GMT

Introduction

These two transforms have a lot of same point, so I want to introduce them together.

First of all, what's kind of problem these algorithm solve? It's used to solve formula like below format:

$$ c_k = \sum_{i\oplus j = k} a_i\times b_j $$

$\oplus$ can be any binary bitwise operations such as or, and, xor, etc.

And FMT(Fast Mobius Transform) is used to solve above formula when operation is or or and, FWT(Fast Walsh-Hadamard Transform) is used when operation is xor.

These two algorithms are too similar so that maybe you can see some blog or solution said they are same algorithm but please remember they not.

FMT

Let's start with operation or.

The algorithm flow is:

Find a transform to transfer array $a, b$, let the array transfered named $A,B$;
Define $C$ such that $C_i = A_i\times B_i$;
Use the inverse transform to get $c$ from $C$.

Or Operation

now the formula is: $$ c_k = \sum_{i\lor j = k} a_i\times b_j $$

We need construct a kind of transform by the algorithm flow. Let $$ A_i = \sum_{i=i\cup j} a_j $$

And we can try derive it:

$$ \begin{aligned} A_i\times B_i &= \left(\sum_{i\cup j=i}a_j\right)\left(\sum_{i\cup k=i}b_k\right)\ &= \sum_{i\cup(j\cup k) = i}a_jb_k\ &= C_i \end{aligned} $$

This form can use a inverse transform to get $c$ form $C$.

Now try find a quick way to calculate this transform. We know $i=i\cup j$ equal to find all the subset $j$ of $i$, and this need $O(3^n)$ time complexity, too slow.

Maybe we can focus on index:

origin index	0	1	2	3	4	5	6	7
binary form	000	001	010	011	100	101	110	111

There is obviously a pattern: 0 and 4, 1 and 5, 2 and 6, etc. They have the same last two bits, and 0 is a subset of 4. This told us we can use this pattern make we calculate transform quickly.

auto FMTor(const std::vector<ll>& a, int flag) -> std::vector<ll> {
    auto trA{a};
    for (int o{2}, k{1}; o <= n; o <<= 1, k <<= 1) {
        for (int i{0}; i < n; i += o) {
            for (int j{0}; j < k; j++) {
                trA[i+j+k] = (trA[i+j+k] + trA[i+j] * flag % MOD + MOD) % MOD;
            }
        }
    }
    return trA;
}

The time complexity of this code optmize above transform to O(n\times 2^n), because the length of array is $2^n$, maybe we can consider this algorithm is $O(n\log n)$ time complexity.

And Operation

The algorithm flow is same.

We are trying to find a transform like FMT Or operation.

Let $A$ is the array after transform, we have: $$ A_i = \sum_{i=i\cap j} a_j $$

That means $j$ is the superset of $i$, so just like before but we should add contribution from superset to subset.

auto FMTand(const std::vector<ll>& a, int flag) -> std::vector<ll> {
    auto trA{a};
    for (int o{2}, k{1}; o <= n; o <<= 1, k <<= 1) {
        for (int i{0}; i < n; i += o) {
            for (int j{0}; j < k; j++) {
                trA[i+j] = (trA[i+j] + trA[i+j+k] * flag % MOD + MOD) % MOD;
            }
        }
    }
    return trA;
}

Full Template

Really not difficult

/**
 * @file    : FastMobiusTransform.cpp 
 * @date    : 2026-01-15
 * @brief   : LuoguP4717
 */

#include <iostream>
#include <vector>

#include <iostream>
#include <vector>

class FastMobiusTransform {
private:
    using ll = long long;

    const int MOD;
    int n;
    std::vector<ll> a, b;
public:
    explicit FastMobiusTransform(int n, int MOD) : MOD{MOD}, n{n}, a(n), b(n) {}
    FastMobiusTransform(int MOD, const std::vector<ll> a, const std::vector<ll> b)
        : MOD{MOD}, n(a.size()), a{a}, b{b} {}

    void input() {
        for (int i{0}; i < n; i++) {
            std::cin >> a[i];
        }
        for (int i{0}; i < n; i++) {
            std::cin >> b[i];
        }
    }

    auto FMTor(const std::vector<ll>& a, int flag) -> std::vector<ll> {
        auto trA{a};
        for (int o{2}, k{1}; o <= n; o <<= 1, k <<= 1) {
            for (int i{0}; i < n; i += o) {
                for (int j{0}; j < k; j++) {
                    trA[i+j+k] = (trA[i+j+k] + trA[i+j] * flag % MOD + MOD) % MOD;
                }
            }
        }
        return trA;
    }
    auto FMTand(const std::vector<ll>& a, int flag) -> std::vector<ll> {
        auto trA{a};
        for (int o{2}, k{1}; o <= n; o <<= 1, k <<= 1) {
            for (int i{0}; i < n; i += o) {
                for (int j{0}; j < k; j++) {
                    trA[i+j] = (trA[i+j] + trA[i+j+k] * flag % MOD + MOD) % MOD;
                }
            }
        }
        return trA;
    }

    auto transformOr() -> std::vector<ll> {
        auto trA = FMTor(a, 1);
        auto trB = FMTor(b, 1);
        std::vector<ll> trC(n);
        for (int i{0}; i < n; i++) {
            trC[i] = trA[i] * trB[i] % MOD;
        }
        return FMTor(trC, -1);
    }
    auto transformAnd() -> std::vector<ll> {
        auto trA = FMTand(a, 1);
        auto trB = FMTand(b, 1);
        std::vector<ll> trC(n);
        for (int i{0}; i < n; i++) {
            trC[i] = trA[i] * trB[i] % MOD;
        }
        return FMTand(trC, -1);
    }
};

auto main() -> int {
    int n, MOD;
    std::cin >> n >> MOD;
    FastMobiusTransform fmt(1<<n, MOD);
    fmt.input();

    auto ans_or{fmt.transformOr()};
    for (auto& p : ans_or) {
        std::cout << p << ' ';
    }
    std::cout << "\n";
    auto ans_and{fmt.transformAnd()};
    for (auto& p : ans_and) {
        std::cout << p << ' ';
    }
    std::cout << "\n";
    return 0;
}

FWT

As you can see this part we are going to introduce FWT, this algorithm is using to solve below formula: $$ c_k = \sum_{i\oplus j = k} a_i\times b_j $$

$\oplus$ indicates XOR operator.

Let $A$ is the transformed array of $a$ that: $$ A_i = \sum_{i\circ j = 0} a_j - \sum_{i\circ j = 1} a_j $$

In the formula, $i\circ j$ indicates $\operatorname{popcount}(i\cap j)\bmod 2$

And we can check its correctness:

$$ \begin{aligned} A_i\times B_i &= \left(\sum_{i\circ j = 0} a_j - \sum_{i\circ j = 1} a_j\right)\times \left(\sum_{i\circ k = 0} b_k - \sum_{i\circ k = 1} b_k\right)\ &= \left(\sum_{i\circ j = 0} a_j\sum_{i\circ k = 0} b_k + \sum_{i\circ j = 1}a_j\sum_{i\circ k = 1} b_k\right) - \left(\sum_{i\circ j = 0} a_j\sum_{i\circ k = 1} b_k + \sum_{i\circ j = 1}a_j\sum_{i\circ k = 0} b_k\right)\ &= \sum_{(j\oplus k)\circ i = 0} a_ib_k - \sum_{(j\oplus k)\circ i = 1} a_ib_k\ &= C_i \end{aligned} $$

The transformation between second row and third row is because each of they denote one situation of result of $i\oplus j$, so they mix to one part.

How to calculate it? Still divide, we know that:

Do "$\circ$" operater	0	1
0	0	0
1	0	1

So that: $$ {A'}_0 = A_0+A_1\ {A'}_1 = A_0-A_1 $$

Also we can get inverse transform: $$ A_0 = \frac{A'_0+A'_1}{2}\ A_1 = \frac{A'_0-A'_1}{2} $$

Code also easily.

Full Template

/**
 * @file    : FastWalshTransform.cpp 
 * @date    : 2026-01-15
 * @brief   : LuoguP4717
 */

#include <iostream>
#include <vector>

class FastWalshTransform {
private:
    using ll = long long;

    const int MOD;
    int n;
    std::vector<ll> a, b;

    auto pow2(int x) {
        ll ans = 1, a = 2;
        while (x) {
            if (x & 1) ans = ans * a % MOD;
            a = a * a % MOD;
            x >>= 1;
        }
        return ans;
    }
public:
    explicit FastWalshTransform(int n, int MOD) : MOD{MOD}, n{n}, a(n), b(n) {}
    FastWalshTransform(int MOD, const std::vector<ll> a, const std::vector<ll> b)
        : MOD{MOD}, n(a.size()), a{a}, b{b} {}

    void input() {
        for (int i{0}; i < n; i++) {
            std::cin >> a[i];
        }
        for (int i{0}; i < n; i++) {
            std::cin >> b[i];
        }
    }

    auto fwtXor(const std::vector<ll>& a, int flag) -> std::vector<ll> {
        auto trA{a};
        for (int o{2}, k{1}; o <= n; o <<= 1, k <<= 1) {
            for (int i{0}; i < n; i += o) {
                for (int j{0}; j < k; j++) {
                    auto u{trA[i+j]}, v{trA[i+j+k]};
                    trA[i+j] = (flag * (trA[i+j] + v) % MOD + MOD) % MOD;
                    trA[i+j+k] = (flag * (u - trA[i+j+k]) % MOD + MOD) % MOD;
                }
            }
        }
        return trA;
    }

    auto transform() -> std::vector<ll> {
        auto trA{fwtXor(a, 1)};
        auto trB{fwtXor(b, 1)};
        std::vector<ll> trC(n);
        for (int i{0}; i < n; i++) {
            trC[i] = trA[i] * trB[i] % MOD;
        }
        return fwtXor(trC, pow2(MOD-2));
    }
};

auto main() -> int {
    int n, MOD;
    std::cin >> n >> MOD;
    FastWalshTransform fwt(1<<n, MOD);
    fwt.input();
    auto ans{fwt.transform()};
    for (auto& p : ans) {
        std::cout << p << ' ';
    }
    std::cout << "\n";
    return 0;
}

Summarize

That's all, actually these knowledge doesn't usefull in OI, but we still need learn it...

Solution Report of Probability and Expectation Topic

Sun, 04 Jan 2026 08:33:34 GMT

A - Luogu P2719 搞笑世界杯

Problem Statement

This is a straightforward problem. We can solve it easily using DP.

DP State:
Let $dp[i][j]$ denote the probability that A and B end up with the same type of ticket when there are $i$ A-type tickets and $j$ B-type tickets remaining.

Answer:
Obviously, the final answer is $dp[n][n]$.

Initialization:
When only one type of ticket remains, A and B will get the same type for sure, except for the case where only one ticket is left.
So we have: $dp[i][0] = dp[0][i] = 1$ for $i \ge 2$.

State Transition:
Each ticket is sold based on a fair coin flip, so each choice has a probability of 50%. Therefore, $$ dp[i][j] = \frac{dp[i-1][j] + dp[i][j-1]}{2} $$

I won't include the code here since the implementation is straightforward.

B - Luogu P8804 [蓝桥杯 2022 国 B] 故障

Problem Statement

The basic application of Bayes' formula.

The original statement is long and packed with information, which makes it hard to follow at first glance.
So the first step is to rewrite it in a more formal and structured way.

Let $P(A)$ denote the probability that event $A$ occurs, and $P(A \mid B)$ denote the probability that $A$ occurs given that $B$ has occurred.

$S_i$ denotes the $i$-th fault Symptom
$C_i$ denotes the $i$-th fault Cause

Since both terms come with the prefix “fault” and can be confusing, we will simply use the English words Symptom and Cause in the following discussion.

The problem provides:

The prior probability of each Cause $i$, namely $P(C_i)$
The conditional probability $P(S_j \mid C_i)$, meaning that Symptom $j$ occurs given Cause $i$
A set $S$ of Symptoms that have already been observed

Our task is to compute the probability of each Cause occurring and then sort them accordingly.

Important assumptions:

The system can have only one active Cause
Given a Cause, all Symptoms occur independently

Based on the conditions above, this is a standard application of Bayes' theorem.
The probability that Cause $i$ is responsible for the observed symptoms can be written as:

$$ P(C_i \mid S) = \frac{P(S \mid C_i) \cdot P(C_i)}{P(S)} $$

For clarity, we summarize the notation again:

$C_i$: the $i$-th Cause
$S_j$: the $j$-th Symptom
$S$: the set of observed Symptoms

Thus, the problem reduces to efficiently computing $P(S \mid C_i)$ and $P(S)$.
The prior probability $P(C_i)$ is already given in the input.

Since all Symptoms are independent given a Cause, we have:

$$ P(S \mid C_i) = \prod_{j \in S} P(S_j \mid C_i) \times \prod_{j \notin S} \left(1 - P(S_j \mid C_i)\right) $$

Note that $S$ represents a specific combination of symptoms.
Therefore, we must consider not only that all symptoms in $S$ have occurred, but also that all symptoms not in $S$ have not occurred.

Once $P(S \mid C_i)$ is known, computing $P(S)$ becomes straightforward.
Since the system can have only one active Cause, we can treat this as a weighted sum:

$$ P(S) = \sum_{i=1}^{n} P(S \mid C_i) \cdot P(C_i) $$

With these probabilities computed, we can obtain $P(C_i \mid S)$ for each Cause and sort them as required.

D - Luogu P1297 [国家集训队] 单选错位

Problem Statement

Let's analyze this case by case.

Case 1 $a_i = a_{i+1}$: In this case, it's clear that the answer for question $i+1$ is also random. The expected value is: $\frac{1}{a_i} = \frac{1}{a_{i+1}}$
Case 2 $a_i > a_{i+1}$: only $\frac{a_{i+1}}{a_i}$ of the possible answers for question $i$ fall within the range $1 \sim a_{i+1}$. Thus, the expected value is: $\frac{a_{i+1}}{a_i} \cdot \frac{1}{a_{i+1}} = \frac{1}{a_i}$
Case 3 $a_i < a_{i+1}$: the random answer for question $i$ is only within $1 \sim a_i$, and the probability that the correct answer for question $i+1$ falls within this range is $\frac{a_i}{a_{i+1}}$. So the expected value becomes: $\frac{a_i}{a_{i+1}} \cdot \frac{1}{a_i} = \frac{1}{a_{i+1}}$

Combining all cases, the final answer is: $$ \sum_{i=1}^{n} \frac{1}{\max(a_i, a_{i+1})} $$

E - Luogu P1850 [NOIP 2016 提高组] 换教室

DP State: $dp[i][j][k]$ denote for a prefix of classroom $[1, i]$, switch classroom for $j$ times, and we decide (not) to switch classroom on $i$ (record by $k$, 1 for yes and 0 for no).

Transition:

int C1 = c[i - 1][0];
int C2 = c[i - 1][1];
int C3 = c[i][0];
int C4 = c[i][1];

dp[i][j][0] = std::min(
    dp[i][j][0],
    std::min(
        dp[i - 1][j][0] + mp[C1][C3], // not change anymore
        dp[i - 1][j][1]               // change on i-1 but i not
            + mp[C1][C3] * (1 - k[i - 1])
            + mp[C2][C3] * k[i - 1]
    )
);

dp[i][j][1] = std::min(
    dp[i][j][1],
    std::min(
        dp[i - 1][j - 1][0]           // change on i but i-1 not
            + mp[C1][C3] * (1 - k[i])
            + mp[C1][C4] * k[i],
        dp[i - 1][j - 1][1]           // change both i-1 and i
            + mp[C2][C4] * k[i] * k[i - 1]
            + mp[C2][C3] * k[i - 1] * (1 - k[i])
            + mp[C1][C4] * (1 - k[i - 1]) * k[i]
            + mp[C1][C3] * (1 - k[i - 1]) * (1 - k[i])
    )
);

Answer is obviously.

F - Luogu P3750 [六省联考 2017] 分手是祝愿

DP State: $dp[i]$ denote the expect operator number when button quantity we need press decrease from $i$ to $i-1$.

Transition: $$ dp[i] = \frac{i}{n}\times 1 + \frac{n-i}{n} \times (dp[i]+dp[i+1]+1) $$

This transition means have $\frac i n$ probability press right button, and have $\frac{n-i}{n}$ probability press wrong button. if we press wrong button, we need pay $dp[i+1]$ to make the button quantity we need press decrease to $i$ again, and continue using $dp[i]$ times operation.

then we need simplify the transition equation: $$ dp[i] = \frac{n+(n-i)\times f[i+1]}{i} $$

Now answer is obviously.

G - Luogu P2473 [SCOI2008] 奖励关

DP State: $dp[i][S]$ denote the expected score from round $i$ to round $k$ when, after the first $i−1$ rounds, the selection state of each item is $S$.

Transition:
For all $i\le j\le n$

if $S$ satisfy the state requirement of item $j$, we can decide to select it or not;
or, just not select it.

Now answer is obiously.

Summarize

Above is the all problem of this topic.

Most of problem with probability or expectation will not use very further knowledge so just solve these problem like solving basic DP problem.

DP Optimize

Wed, 24 Dec 2025 16:58:01 GMT

Decision Monotonicity

Decision Monotonicity is a key concept for optimizing dynamic programming transitions.

The idea of decision monotonicity is that the decision points of the DP exhibit a monotonic property. Before introducing this concept, we first define what a decision point is.

Definition of Decision Point

For a fixed index $i$, an index $j$ is called a decision point of $i$ if, for all $j' < i$, $g(j) + w(j, i) \le g(j') + w(j', i)$.

In this case, $i$ is referred to as the decision-affected point.

Note that there may be multiple decision points corresponding to the same $i$.

Intuitively, a decision point is an index that attains the optimum in the DP transition for state $i$.

Having defined decision points, we can now introduce decision monotonicity. Its precise definition depends on the specific form of the DP transition equation. In the following sections, we will discuss different cases separately.

Prefix Transition

The standard form of a prefix transition is

$$ f[i] = \min_{j<i} { g[j] + w(j,i) }. $$

If $f = g$, this transition is called a self-transition.
Otherwise, it is called a heterogeneous transition.

Decision Monotonicity in Prefix Transitions

Definition (Decision Monotonicity for Prefix Transitions).

A prefix transition is said to satisfy decision monotonicity if the following conditions hold.

Let $ i_1 \le i_2 $.

For every decision point $ j_1 $ of $ i_1 $, there exists a decision point $ j_2 $ of $ i_2 $ such that $j_1 \le j_2$.

For every decision point $ j_2 $ of $ i_2 $, there exists a decision point $ j_1 $ of $ i_1 $ such that $j_1 \le j_2$.

Intuitively, decision monotonicity in prefix transitions means that the indices of decision points are non-decreasing as the state index $ i $ increases.

In the following sections, we will discuss how to optimize prefix DP transitions when the transition satisfies decision monotonicity.

Divide-and-Conquer Strategy

This strategy is applicable only to prefix heterogeneous transitions.

Algorithm Overview

Compute the decision point for the midpoint of the current range.

By decision monotonicity, the valid range of decision points for each subrange can be restricted accordingly.

As a result, each decision point is evaluated at most a constant number of times, and the overall time complexity is $O(n\log n)$.

This algorithm is remarkably elegant. When I first encountered it, I was genuinely impressed by its simplicity and efficiency.

Quadrilateral Inequality

For self-transitions, additional conditions are required to optimize the DP.
The quadrilateral inequality is one such condition.

Definition (Quadrilateral Inequality).

A function $w(i, j)$ is said to satisfy the quadrilateral inequality if, for all $a \le b \le c \le d$, the following inequality holds: $$ w(a, c) + w(b, d) \le w(a, d) + w(b, c). $$ Remark: The inequality sign here is only a formal representation. Its essential meaning is that $w(a, c) + w(b, d)$ yields a better (or no worse) cost than $w(a, d) + w(b, c)$.

There is a well-known theorem stating that if the cost function $w$ satisfies the quadrilateral inequality, then the corresponding DP transition exhibits decision monotonicity.

Proof.

According to the definition of decision monotonicity, it suffices to verify the following two symmetric conditions:

For every decision point $j_1$ of $i_1$, there exists a decision point $j_2$ of $i_2$ such that $j_1 \le j_2$.

For every decision point $j_2$ of $i_2$, there exists a decision point $j_1$ of $i_1$ such that $j_1 \le j_2$.

Since the two cases are symmetric, we only prove the first one.

Let $i_1 < i_2$, and suppose $j_1$ is a decision point of $i_1$.
By definition, for all $j' < j_1$, we have $$ g[j_1] + w(j_1, i_1) \le g[j'] + w(j', i_1). $$

Now let $a = j'$, $b = j_1$, $c = i_1$, and $d = i_2$.
By the quadrilateral inequality, it follows that $$ w(j', i_1) + w(j_1, i_2) \le w(j', i_2) + w(j_1, i_1). $$

Adding the two inequalities above yields $$ g[j_1] + w(j_1, i_2) \le g[j'] + w(j', i_2). $$

This shows that when the decision-affected point moves from $i_1$ to $i_2$, the index $j_1$ remains no worse than any $j' < j_1$.
Therefore, the decision point of $i_2$ must be greater than or equal to $j_1$.

Hence, the DP transition satisfies decision monotonicity.

Quadrilateral Inequality can be derived to possess stronger properties.
This requires starting from another understanding form of Quadrilateral Inequality.

Starting from the original inequality, we can make a simple transformation:

$$ \begin{aligned} w(a, c) + w(b, d) &\le w(a, d) + w(b, c), \ w(a, d) - w(a, c) &\ge w(b, d) - w(b, c), \ \bigl(g[a] + w(a, d)\bigr) - \bigl(g[a] + w(a, c)\bigr) &\ge \bigl(g[b] + w(b, d)\bigr) - \bigl(g[b] + w(b, c)\bigr). \end{aligned} $$

How should we interpret this inequality?

When the decision-affected point moves from $c$ to $d$,
the increase in cost when choosing index $a$ as the decision point is no smaller than the increase when choosing index $b$ as the decision point.

We call this phenomenon Gradual Deterioration.

Intuitively, Gradual Deterioration provides another way to understand decision monotonicity under the quadrilateral inequality: as the decision-affected point increases, earlier decision points incur higher marginal costs than later ones. As a result, the optimal decision point shifts monotonically forward.

Moreover, Gradual Deterioration reveals an even stronger property:

For ANY two indices $j_1 < j_2$, there exists a dividing point $x$ such that

for decision-affected points with index less than $x$, choosing $j_1$ is better;
for decision-affected points with index greater than $x$, choosing $j_2$ is better.

Obviously, a transition with this property must possess decision monotonicity, but a transition with decision monotonicity may not necessarily satisfy this property.

Binary-Queue

The conclusion of Gradual Deterioration inspires a new idea for optimizing DP.

Let $x_j$ denote the dividing point associated with decision point $j$. If $x_{j-1} \ge x_j$, then decision point $j+1$ becomes better than $j$ before $j$ ever becomes better than $j-1$.
As a result, $j$ will never be an optimal decision point.

This observation allows us to design an algorithm that safely ignores all such decision points. By discarding them during the transition process, the DP can be computed much more efficiently.

From the above derivation, we are motivated to maintain an increasing sequence of boundary points and their corresponding optimal decision points $j_1, j_2, \ldots, j_m$.

Suppose we have already processed state $i-1$ and maintained the decision points $j_1, j_2, \ldots, j_m$ for $i-1$. Now we consider state $i$. When inserting a new possible decision point $i-1$ at the back, we first compute the boundary point $x_m$ between $i-1$ and $j_m$. If $x_{m-1} \ge x_m$, then $j_m$ will never become an optimal decision point and can be removed. By repeatedly applying this process, and finally inserting $i-1$, we can maintain a sequence of decision points with strictly increasing boundary points.

For the current decision-affected point $i$, if $j_1$ is worse than $j_2$, then all subsequent points will also prefer $j_2$, and thus $j_1$ can be safely removed. Repeating this process until $j_1$ becomes better than $j_2$, we conclude that $j_1$ is the decision point for $i$, according to the previous derivation.

The above procedure can be conveniently implemented using a deque. Each decision point is inserted into and removed from the deque at most once, so this part contributes linear time complexity.

The key remaining issue is how to compute the boundary point $x$. By the property of Gradual Deterioration, $x$ is monotonic and thus can be found by binary search.

Using binary search to compute $x$, the entire process of self-transition /heterogeneous-transition optimization can be accelerated to $O(n \log n)$.

This method is known as the binary queue optimization algorithm.

Slope Optimization

We can impose additional conditions to further optimize DP. In some transitions, the cost function $w(i,j)$ has the form $$ w(i,j) = a(i) + b(j) + c(i)d(j). $$

This form has a very nice property. Let us discuss under what conditions such a function $w(i,j)$ satisfies the quadrilateral inequality.

By the principle of Gradual Deterioration, consider indices $ j_1 \le j_2 \le i_1 \le i_2. $ We have $$ \begin{aligned} w(j_1,i_2) - w(j_1,i_1) &\ge w(j_2,i_2) - w(j_2,i_1), \ c(i_2)d(j_1) - c(i_1)d(j_1) &\ge c(i_2)d(j_2) - c(i_1)d(j_2), \ \bigl(c(i_2) - c(i_1)\bigr)\bigl(d(j_2) - d(j_1)\bigr) &\le 0. \end{aligned} $$

The derivation above shows that when $c$ and $d$ have opposite monotonicity, the function $w$ satisfies the quadrilateral inequality. Since $w$ only depends on the product $c(i)d(j)$, we can always reorder the indices so that $c$ is non-decreasing and $d$ is non-increasing.

Under this condition, for a decision-affected point $i$, we only need to compute $ b(j) + c(i)d(j). $ This expression is exactly the value of a line evaluated at $x = c(i)$. Therefore, the dividing point between two decision points can be obtained by computing the intersection of two lines, rather than by binary search.

This technique is known as Slope Optimization. It can be viewed as a special case of Binary Queue Optimization and runs in linear time, $O(n)$.

If $c$ and $d$ do not have such monotonic properties, we can instead use a Li Chao Segment Tree to maintain the lines and query their values at $c(i)$, resulting in a time complexity of $O(n \log n)$. I have already written a detailed introduction to this method in a previous blog post.

Link:
Li Chao Segment Tree

Anti quadrilateral inequality and Binary-Stack

same with before. we called below formula Anti Quadrilateral inequality. $$ w(a,c)+w(b,d) \ge w(a,d)+w(b,c) $$ also we have property like Gradual Deterioration, we called Gradual Optimization. But when a transition fit Anti Quadrilateral inequality has no Decision Monotonicity.

Why? Because a Decision Point can be good when it just add in our decision, but when the index of Decision-affected increasing, old Decision Point will be better, so this type of transition don't has Decision Monotonicity.

But we still can use some structure to maintain this.

For a fixed state $i$, we consider all possible decision points $1, 2, \ldots, i-1$.Under Gradual Optimization, for each candidate decision point $j$, there exists a dividing point $x_j$ such that after $x_j$, choosing $j$ becomes better than choosing $j+1$.

Now observe that if $x_{j-1} \le x_j$, then before $j$ ever becomes better than $j+1$ (at $x_j$), $j-1$ has already become better than $j$ (at $x_{j-1}$). This means that $j$ can never be the optimal decision point at any time, and therefore can be safely discarded.

By repeatedly applying this elimination process, we obtain a sequence of candidate decision points $j_1, j_2, \ldots, j_m.$ Moreover, if $j_k$ becomes better than $j_{k+1}$ at time $x_k$, then the dividing points must satisfy $x_1 > x_2 > \cdots > x_{m-1}$.

Next, consider the current state $i$. If the last candidate decision point $j_m$ is worse than $j_{m-1}$, then by Gradual Optimization, $j_m$ will never become optimal in the future, and thus can be removed as well.

It is easy to see that once $j_m$ becomes better than $j_{m-1}$, $j_m$ is the optimal choice for the current state $i$—that is, the decision point for $i$.

Range Transition

This type of transition is relatively simple. The standard form of a range transition is

$$ f[i][j] = \min_{i \le k < j} \bigl{ f[i][k] + f[k+1][j] + w(i,j) \bigr}. $$

If the cost function $w(i,j)$ satisfies the quadrilateral inequality and the following condition (which we call including monotonicity), $$ w(b,c) \le w(a,d), $$ then this transition is said to have decision monotonicity.

Just as in prefix transitions, this property allows us to optimize the DP to a time complexity of $O(n^2)$.

Summary

This article discusses several techniques for DP optimization. Many problems involve these ideas, and dynamic programming itself is a fundamental topic in OI.

However, techniques are only tools. What truly matters is understanding when and how to adapt them to different problems.

Hello Everyone!

Wed, 24 Dec 2025 10:47:01 GMT

As you may have noticed, my blog has undergone a major update. The old blog, previously hosted at https://old.517group.cn, is no longer being maintained.

Articles from the old blog will not be migrated to this new site. All future content will be published exclusively here.

Thank you all for your continued support.