XianRui's Blog

How to Calculate the General Term Formula

Tue, 16 Jun 2026 13:51:22 GMT

This passage is used to introduce how to calculate general term formula by linear recursive formula. Let's know some basic information before we start.

Linear: Each term is a linear term of $a$. For example it doesn't exist: $a_i \times a_j$, ${a_i}^2$.
Homogeneous: There is no extra $f(n)$ at end. Warning: constant function ($f(n)$ is always the constant) also be included.
Constant Coefficients: All coefficients of $a$ is constant.
Order $k$ : The current item depends on at most the first k items before it.

Then you can use these tags to check which kind of recursive formula fit this article.

Linear Homogeneous Recurrence with Constant Coefficients

This is the most easy one. This kind of recurrence can be express by below formula:

$$ a_n = c_1a_{n-1} + c_2a_{n-2} + \cdots + c_ka_{n-k} $$

For this kind of recurrence, we can use a general method called characteristic equation to solve it. The Core idea of characteristic equation is: An exponential sequence $r^n$ only changes by a constant factor when shifted.

So we can let $a_n = r^n$, give you a example: $$ 25 a_n + 20 a_{n-1} = 12 a_{n-2} $$

Then we have:

$$ \begin{aligned} 25 r^n + 20 r^{n-1} &= 12 r^{n-2} \ 25 r^2 + 20 r &= 12 \ 25 r^2 + 20 r - 12 &= 0 \end{aligned} $$

This is characteristic equation, then we can calculate $r$ by it. And we should have some little categorical discussion on it.

Different Root

Define the solution set is $r_1, \dots ,r_k$, then the recurrence can be expressed by

$$ a_n = \sum_{i=1}^k A_i {r_i}^n $$

Then if problem give we the first $k$ element, we can calculate the coefficients $A$ by them.

As the example I give, the root of $25 r^2 + 20r -12 = 0$ is $r_1 = \frac{2}{5}, r_2 = -\frac{6}{5}$, so we can write the general terms as

$$ r_n = A (\frac{2}{5})^n + B (-\frac{6}{5})^n $$

Then if we have any two element of this sequence we can calculate $A, B$, but in this problem, question setter give u only $a_0$. What to do? hold on. The setter give us a special condition: $\forall i \ge 0$ satisfy $a_i \ge 0$.

The second term is a negative number less than $-1$, so as $n$ increase, the absolute value of it will increase and it's positive and negative alternately. But the first term is decrease as $n$ increase. So it $B \not = 0$, we always exist $a_i < 0$.

So the answer is obvious. $A = a_0, B = 0$, the general term of $a$ is $$ a_n = a_0 \times \left(\frac{2}{5}\right)^n $$

Repeat Root

If the characteristic equation is $$ \sum_{i=1}^k (r-r_i)^{m_i} = 0 $$

We can express general term as

$$ a_n = \sum_{i=1}^k \left[\left(\sum_{j=0}^{m_i}C_{i,j}n^j\right){r_i}^n\right] $$

OK, I know it is hard to understand such a ugly expression, so let's see a example.

$$ \begin{aligned} & a = {1, 6, 20, \dots } \qquad \text{index start from 0}\ & a_n = 4 a_{n-1} - 4 a_{n-2} \ \end{aligned} $$

Let $a_n = r^n$, then we can have below characteristic equation

$$ \begin{aligned} r^n &= 4 r^{n-1} - 4 r^{n-2} \ r^2 &= 4r - 4\ r^2 - 4r + 4 &= 0 \ (r - 2)^2 &= 0 \end{aligned} $$

Ok know we have repeat root. Base on formula above, we have below general term.

$$ a_n = (A + Bn) 2^n $$

Then We can use the first two terms to solve for A and B

$$ \begin{cases} 1 = (A + B \times 0) \times 2^0 \ 6 = (A + B \times 1) \times 2^1 \end{cases} \qquad \begin{cases} A = 1\ B = 2 \end{cases} $$

So the final general term of this sequence is

$$ a_n = (1 + 2n) \times 2^n $$

You can verify it using enumeration.

Linear non-Homogeneous Recurrence with Constant Coefficients

But we know, in lot of stuation, the recurrence always non-homogeneous. So should we give up? No! This part let we know how to solve general term in linear non-homogeneous recurrence with constant coefficients.

Also we start with a little example.

$$ \begin{aligned} a_0 &= 1 \ a_n &= 2 a_{n-1} + 3 \end{aligned} $$

We should find a sequence $p$ which also satisfy this recurrence. In this case, we can find a sequence $p = {-3,-3,-3,\cdots}$. The core idea is to minus the non-homogeneous part of origin recurrence.

So now we have two sequence: $a_n = 2a_{n-1}+3, p_n = 2p_{n-1}+3$, if we let the recurrence of $a$ minus $p$, we will take a sequence $d$, and this sequence is a linear homogeneous recurrence with constant coefficients.

$$ \begin{aligned} d_n &= a_n - p_n \ &= (2a_{n-1} + 3) - (2 p_{n-1} + 3)\ &= 2(a_{n-1} - p_{n-1})\ &= 2d_{n-1} \end{aligned} $$

Then use common sense or the method I introduce last part, we can know $d_n = A 2^{n}$, substitute $d_n$ and $p_n$ we will get general term of $a_n$

$$ \begin{aligned} a_n = p_n + d_n\ a_n = -3 + A2^n \end{aligned} $$

Then we can use the start value of $a$ to calculate value of $A$, it's $8$.

Summarize

This article introduce some common and easy situation when we are translating recurrence to general term. In most of situation, Matrix Fast Exponentiation also OKay. But math can optmize $O(k^3 \log n)$ to $O(1)$

Solution Report of Balance Tree(Medium) Topic

Wed, 10 Jun 2026 19:57:25 GMT

P1552 [APIO2012] 派遣

The problem gives we a directed and rooted tree. So we can use DSU on tree to solve this problem.

For each leaf, initialize a DS with this node. When combine information of son to take more ninja in limit, pop the most expensive ninja and leader is now node, so answer is set.size() * leader[u].

P2173 [ZJOI2012] 网络

We noticed that the color in this problem less than 10 type. So we can maintain information of each chain which different color. Actually, it's a common trick to maintain chain.

When connect node $u$ and $v$, we should check they must on different chain, and because of nature of chain, $u,v$ must be the endpoints of their chain. This part we can write a function link to quick check it's valid to connect these node or not.

For operator 1, we can regard it as cut and link, so the link function in last part can be used here. Cut operator is easy, FHQ-Treap can do split operator easily.

P2497 [SDOI2012] 基站建设

Let $f_i$ denotes the minimum cost make node $i$ connect to starter.

We can get a transition function that $f_i = \min_{j<i}(f_j+w(i,j))$, and function $w(i,j)$ denotes the minimum cost to connect node $i$ and node $j$. We can use Pythagorean theorem to expand it.

$$ \begin{aligned} \because\ \text{Pythagorean\ theorem,} & \ (r'_i - r_j)^2 + (x_i - x_j)^2 = (r'_i + r_j)^2 \ \therefore\ r'_i = & \frac{(x_i-x_j)^2}{4r_j} \ \ w(i,j) &= \sqrt{r'_i} + v_i \ &= \sqrt{\frac{(x_i-x_j)^2}{4r_j}} + v_i\ &= \frac{x_i-x_j}{2\sqrt{r_j}} \end{aligned} $$

Then we can change transition function to: $$ \begin{aligned} f_i &= f_j + \frac{x_i}{2\sqrt{r_j}} - \frac{x_j}{2\sqrt{r_j}} + v_i\ f_i-v_i &= \left(\frac{1}{2\sqrt{r_j}}\right)x_i + \left(f_j - \frac{x_j}{2\sqrt{r_j}}\right) \end{aligned} $$

Li-Chao Segment tree can solve this problem easily, just query minimum at $x_i$, transition, and push line $i$.

P3081 [USACO13MAR] Hill Walk G

Most of solution in luogu is using Lichao Segment Tree. But I want to solve these problem by Balance Tree. So here is a different solution.

Also we need scanning-line to find all segment which satisfy $x_1 \le x < x_2$ ($x$ is the position bassie located), then we need to find a way to sort these segment let we can use single operator such eraser begin to maintain answer quickly.

Because problem promises the segment never cross, so the hierarchical relationship will never changed with position of bassie.

Then we can sort it by now position.

struct Comparator {
    const std::vector<Segment>* seg;
    const ll* sweep_x;

    Comparator(
        const std::vector<Segment>* seg_ptr = nullptr,
        const ll* x_ptr = nullptr
    ) : seg(seg_ptr), sweep_x(x_ptr) {}

    bool operator()(int lhs, int rhs) const {
        if (lhs == rhs) {
            return false;
        }

        const Segment& a = (*seg)[lhs];
        const Segment& b = (*seg)[rhs];
        const ll x = *sweep_x;

        __int128 dx_a = a.x2 - a.x1;
        __int128 dy_a = a.y2 - a.y1;
        __int128 dx_b = b.x2 - b.x1;
        __int128 dy_b = b.y2 - b.y1;

        __int128 val_a =
            (__int128)a.y1 * dx_a + dy_a * (x - a.x1);

        __int128 val_b =
            (__int128)b.y1 * dx_b + dy_b * (x - b.x1);

        __int128 left = val_a * dx_b;
        __int128 right = val_b * dx_a;

        if (left != right) {
            return left < right;
        }

        return lhs < rhs;
    }
};

Left part just like monotonic queue, believe it's easy to realize.

P3215 [HNOI2011] 括号修复 / [JSOI2011] 括号序列

For this classic problem, I am first time knowing that have a formula to calculate answer. We let ( denotes $-1$, ) denotes $1$, define $\text{premax}$ denotes maximum of prefix sum, define $\text{sufmin}$ denotes minimum of suffix sum. Then we can denotes answer by

$$ \bigg\lceil\frac{\text{premax}}{2}\bigg\rceil + \left\lceil\frac{|\text{sufmin}|}{2}\right\rceil $$

The prove is easy. Don't misremember the formula, it's not sum of premax ad sufmin then divide by two, here is a counterexample: )(.

Then we can use FHQ-Treap or Segment Tree to solve this problem easily.

P3224 [HNOI2012] 永无乡

Also a classic problem, in this problem we know Balance Tree also can be used to simulate DSU.

Use Treap to simulate DSU, combine each block and query the k-th maximum is easy.

P3268 [JLOI2016] 圆的异或并

We are given a strange condition just like [USACO13MAR] Hill Walk G, because of the circle in this problem never cross, so the relative position never change. We can use set and scanning-line to calculate nesting levels of a circle.

Then because of we are calculating XOR area, even nesting levels lead to negative and odd lead to positive area.

P3586 [POI 2015 R2] 物流 Logistics

The core idea is to find the total contribution is $$ \sum \min(a_i, s) $$

We will output TAK if total contribution greater than $c\times s$, or output NIE.

Then we can use BIT or Balance Tree solve it easily.

P3968 [TJOI2014] 电源插排

First we can simulate the operation of this problem, to get all possible position. Because full scope can reach $10^9$, but the query just less than $10^5$, so this simulte can help we discretize.

So the first challenge is to simulate it. We can build two set. And one for coming, another one for leaving. More details, let the set used to manage coming to sort by length and right endpoint. So the begin is the range which next student will use.

And when a student leave, we need combine three ranges: [l, x), [x], (x,r]. We let set used to manage leaving sort by left point, then we can use binary search ( find(), the member function of std::multiset) can solve the question easily.

Whatmore, there is a small detail when manage leaving. We can allow empty range exist. For example, there is a range [x, x], then a student use it, we also can make three ranges: [x, x-1], [x,x], [x+1, x]. Although the first and last range is invaild, but it can minus a lot of unnecessary special check.

After simulation, count is easy. This approach is off-line, and count we can use BIT or Segment Tree to solve it easily.

Guide of Traditional Flower Game

Sat, 30 May 2026 14:01:01 GMT

OK, I am the second author of this game, XianRuiDendro. As you can see, this article is here to introduce our game to you, and maybe also to prove that our design team was awake for at least part of the development process.

Sign Up / In / Out

Everything begins with signing up.

For every new account, we prepare one starter character from the permanent pool. These characters are all carefully designed, interesting, and absolutely not suspiciously strong in the hands of your friend who says, “I barely know how to play.”

Signing in is simple. The username and password rules are friendly enough that you will not need a law degree to create an account.

You can find the sign-out button on the left side of the page. We put it there because sometimes people need to leave, even from greatness.

Home Page

After signing in, you will arrive at the home page. There are three portals:

The left portal is Local War, where you can play with a friend offline. Please do not cut the internet connection, though. The game is powerful, but not magic.

The middle portal is Online War. Your wins and losses affect your in-game rank, and your seasonal rewards depend on that rank. This part will be introduced later, because rewards deserve dramatic timing.

The right portal is Computer War, where you can fight bosses. They look serious. You will probably be fine. Probably.

There is also a header.

The leftmost logo is the name of our game. Click it to return to the home page. The other buttons, from left to right, lead to Bag, Reward, Character, Pull, Shop, Announcement, Other, and Settings.

Character Page

Most functions on this page are easy to discover by yourself, which is good, because we believe players should enjoy both combat and mild investigation.

One small but useful feature: you can click the name of a character you own. A window will appear and show detailed information, including how much damage this character can deal with each skill. This is especially useful when you want to explain that your loss was caused by “experimental data collection.”

Fight Mechanism

Here comes the second most important part of the game.

Operation System

In online battles, both players use the same control scheme:

W / A / D: move and jump
S: character skill
K: weapon skill
J: dash
Y: surrender, for players with great emotional intelligence

In local battles, P1 uses W / A / D, S, K, J, and Y.
P2 uses the arrow keys, Numpad 2 for weapon skill, Numpad 1 for dash, and P to surrender.

In Boss mode, Numpad 9 or number 9 can make the Boss surrender. This is not cowardice. This is advanced negotiation.

Every battle has HP, weapon cooldown, character skill cooldown, dash charges, and status effects. Dash charges recover over time, so do not spend all of them just to look stylish. Unless it works. Then it was strategy.

Negative Status

The game currently has several important negative statuses:

Poison: caused by weapons like Flying Sand Talisman. It lasts 10 seconds, ticks every 2 seconds, and can stack up to 5 layers.
Stun: briefly stops your action. Heavy attacks and some skills can cause this.
Bind: usually related to web zones. Leaving the zone can add bind stacks, slowing movement.
Jump Lock: when active, jumping is forbidden. Very rude, very effective.
Vulnerable: makes you take extra damage. This is the game politely saying, “Please reconsider standing there.”

Gacha Mechanism

The gacha system has two kinds of pools: the Permanent Pool and the Limited Pool.

The Permanent Pool contains the starter characters: Qing Lan Walker, Chi Yan Fighter, Ling Mu Watcher, and Ant Summoner. These characters are always treated as permanent characters. They are stable, friendly, and still fully capable of making your opponent question the meaning of balance.

The Limited Pool contains characters outside the permanent list, such as Shadow Ninja and Burning Blade. Limited characters appear as the current UP target when their banner is active.

A single pull costs 1 Great Wenhua.
A ten-pull costs 10 Great Wenhua.
Free ten-pulls do not advance pity counters, because free things are allowed to be nice, but not that nice.

For the Permanent Pool:

Base character rate: 0.6%
80th pull character rate: 3%
From the 81st pull onward, the rate increases
120th pull: guaranteed character

For the Limited Pool:

Total character rate starts at 0.75%
On a character result, there is a 50% chance to get the current UP character
There is also a 50% chance to lose the roll and get a random permanent character
So the starting rate is effectively 0.375% UP and 0.375% permanent spook
80th pull total character rate: 3.75%
Due to the limited multiplier, the total character rate reaches 100% before the normal 120-pull ceiling
If you lose the 50/50 and get a permanent character, the limited guarantee activates
After that, you will get the current UP character within at most 60 paid pulls

In simple player language: if the Limited Pool smiles, you get the UP. If it smiles in a legally different way, you get a permanent character and then the game owes you the UP within 60 pulls. Please remember this sentence when probability starts wearing a fake moustache.

If a paid pull does not produce a character, you receive 1 Residue. Reaching 20 paid pulls without a character grants 1 free ten-pull. Reaching 60 paid pulls without a character grants a Wenhua Voucher, which is converted into 10 Great Wenhua when the banner refreshes.

Duplicate characters work like this:

First copy: unlocks the character
Next copies: become constellation materials, up to 6
After full constellation: extra copies become 5 Wenhua

So even duplicates have value. This is important for morale, especially after the gacha system says “congratulations” in a very suspicious tone.

Paid Mechanism

Now comes the most important part.

The shop sells Wenhua Prototypes. Each top-up tier has its own first-purchase bonus, and every tier calculates the first bonus separately. This means you can enjoy the sacred experience of saying, “Actually, this is very cost-effective.”

Price	Normal Reward	First Top-Up Reward
6 CNY	60 Wenhua Prototypes	60 * 2 Wenhua Prototypes
30 CNY	300 Wenhua Prototypes	300 * 2 Wenhua Prototypes
98 CNY	980 Wenhua Prototypes	980 * 3 Wenhua Prototypes
198 CNY	1980 * 2 Wenhua Prototypes	1980 * 6 Wenhua Prototypes
328 CNY	3280 * 3 Wenhua Prototypes	3280 * 10 Wenhua Prototypes
648 CNY	6480 * 10 Wenhua Prototypes	6480 * 40 Wenhua Prototypes

The 648 CNY first top-up gives 259,200 Wenhua Prototypes (For 40 times of common games). At this point, the number is so large that the calculator also needs a moment.

Wenhua Prototypes can be converted into Wenhua Fragments, and Wenhua Fragments can be converted into Great Wenhua for pulling characters. So the paid system is simple: recharge, convert, pull, win, and then claim it was all skill.

Final Advertisement

Thank you for reading this introduction from XianRuiDendro.

If you are interested in the game, want to follow updates, ask questions, find opponents, or simply watch everyone argue about balance with great confidence, please join our official QQ group:

1106119045

See you in the game.

Solution Report of Balance Tree(Easy) Topic

Wed, 20 May 2026 21:14:25 GMT

P1110 [ZJOI2007] 报表统计

Easy problem, we should maintain a 2D-vector with $n$ row, then answer the question from problem.

For Min_Gap, using a std::set(or Balance Tree) just will have 3 changes when we insert a number: delete old info from old tail and next head, then insert new info from old tail and new element, new info from new element and next head.

For Min_Sort_Gap, using another std::set(or Balance Tree), just query the previous and the next element then find min gap global.

P1486 [NOI2004] 郁闷的出纳员

We noticed that the number of operator A and S just hundred, so voilence add and minus all node is okay; rest part is common Balance tree.

P2869 [USACO07DEC] Gourmet Grazers G

This a problem using a classic idea: Sort by one variable, then use natrue by another variable to solve problem.

Same here, we sort all element (include grass) by taste, then push then into a multiset let it sort by price, then we can find the minimum price.

P3466 [POI 2008] KLO-Building blocks

It is not hard to find we can traverse all $k$-length range and calculate the answer.

Then the best answer is change all element into median. Then we need a data structure which can find median, calculate the sum of all element less (or greater) than a value. This function can use Balance Tree to solve it easily.

P7619 [COCI 2011/2012 #2] RASPORED

If we fire this pancake with order sequence $p$, answer can be express by: $$ \begin{aligned} Answer &= \sum_{i=1}^n\left(L_{p_i}-\sum_{j=1}^iT_{p_j}\right) \ &= \sum_{i=1}^nL_{p_i} - \sum_{i=1}^n(n-i+1)T_{p_i} \end{aligned} $$

Then sum of $L$ can calculate at the beginning, right part can sort $T$ in ascending order. Balance Tree can solve it easily.

P11373 「CZOI-R2」天平

Here's another trick: When we need to check if there exists a sequence $c$ satisfying $\forall c_i\lt\Z$ such that $\sum a_ic_i = v$, and then simply check if $v$ is a multiple of $\gcd(c_i)$.
This is because of Bézù Theorem.

Then it's easy to find that $\gcd(a_i) = \gcd[\gcd(a_1, a_2), \gcd(a_2, a_3), \dots]$ (It's same with prove $\gcd(a,b,c) = \gcd(\gcd(a,b), \gcd(b,c))$, easy to prove by emotional understanding).

Use Subtractive Euclidean Algorithm, that is $\gcd(a, b) = \gcd(a, a-b)$, can be deduced: $$ \begin{aligned} \gcd(a_1, a_2, \dots, a_n) &= \gcd[\gcd(a_1, a_2), \gcd(a_2, a_3), \dots, \gcd(a_{n-1}, a_n)]\ &= \gcd[\gcd(a_1, a_2-a_1), \gcd(a_2, a_3-a_2), \dots, \gcd(a_{n-1}, a_n-a_{n-1})]\ &= \gcd(a_1, \gcd(b_2, b_3, \dots, b_n)) \end{aligned} $$

$b_i = a_i - a_{i-1}$ in above equation.

Then we can use Balance Tree to solve this problem.

Code is difficult.

P12179 DerrickLo's Game

Also a tricky problem, the core idea is: because there is no minus operator, the final sequence will be all maximum of origin sequence. So do second operator with all 2-length subsequence is best. Specially, for element $x-1, x-2, x-3$ will use first operator.

Then we can use Segment Tree to solve this problem.

P14379 【MX-S9-T2】「LAOI-16」摩天大楼

The problem with mex is usually need to think position of number 1.

If a range satisfy $f(l, r)=0$:

there is no 1 in whole range;
the start point and end point of range is 1, and range $(l,r)$ have no $2$.

Emm, nerd writer first think range ${1,2,3,3,2,1}$ also can let $f = 0$, but wrong. That's becase the problem need us find a cut point in range, instead find $\operatorname{mex}$ for whole range.

Left part is easy, use Segment Tree can do counting easy.

Template of FHQ-Treap

Tue, 19 May 2026 21:19:57 GMT

written by ChatGPT.

#include <iostream>
#include <memory>
#include <vector>
#include <array>
#include <cstdint>

template <typename Tp>
using OwnPtr = std::unique_ptr<Tp>;
template <typename Tp>
using RefPtr = Tp*;

class FhqTreap {
private:
    struct Node {
        std::array<RefPtr<Node>, 2> son{nullptr, nullptr};
        int cnt = 0, val = 0, sz = 0;
        std::uint32_t pri = 0;
    };

    std::vector<OwnPtr<Node>> pool;

    std::uint32_t seed = 114514;

    auto rnd() -> std::uint32_t {
        seed ^= seed << 13;
        seed ^= seed >> 17;
        seed ^= seed << 5;
        return seed;
    }

    auto size(RefPtr<Node> x) -> int {
        return x ? x->sz : 0;
    }

    void pushUp(RefPtr<Node> x) {
        if (!x) return;
        x->sz = x->cnt + size(x->son[0]) + size(x->son[1]);
    }

    auto newNode(int v) -> RefPtr<Node> {
        pool.push_back(std::make_unique<Node>());
        auto p = pool.back().get();

        p->val = v;
        p->cnt = p->sz = 1;
        p->pri = rnd();

        return p;
    }

    /*
        equal == false:
            x: val < v
            y: val >= v

        equal == true:
            x: val <= v
            y: val > v
    */
    void split(
        RefPtr<Node> p,
        int v,
        RefPtr<Node>& x,
        RefPtr<Node>& y,
        bool equal = false
    ) {
        if (!p) {
            x = y = nullptr;
            return;
        }

        if (p->val < v || (equal && p->val == v)) {
            x = p;
            split(p->son[1], v, x->son[1], y, equal);
            pushUp(x);
        } else {
            y = p;
            split(p->son[0], v, x, y->son[0], equal);
            pushUp(y);
        }
    }

    auto merge(RefPtr<Node> x, RefPtr<Node> y) -> RefPtr<Node> {
        if (!x || !y) {
            return x ? x : y;
        }

        if (x->pri < y->pri) {
            x->son[1] = merge(x->son[1], y);
            pushUp(x);
            return x;
        } else {
            y->son[0] = merge(x, y->son[0]);
            pushUp(y);
            return y;
        }
    }

    auto kth(RefPtr<Node> x, int k) -> RefPtr<Node> {
        while (x) {
            int ls = size(x->son[0]);

            if (k <= ls) {
                x = x->son[0];
            } else if (k <= ls + x->cnt) {
                return x;
            } else {
                k -= ls + x->cnt;
                x = x->son[1];
            }
        }

        return nullptr;
    }

    auto rightMost(RefPtr<Node> x) -> RefPtr<Node> {
        if (!x) return nullptr;
        while (x->son[1]) x = x->son[1];
        return x;
    }

    auto leftMost(RefPtr<Node> x) -> RefPtr<Node> {
        if (!x) return nullptr;
        while (x->son[0]) x = x->son[0];
        return x;
    }

public:
    RefPtr<Node> rt = nullptr;

    FhqTreap() = default;

    ~FhqTreap() {
        clear();
    }

    void clear() {
        rt = nullptr;
        std::vector<OwnPtr<Node>>().swap(pool);
        seed = 114514;
    }

    void insert(int v) {
        RefPtr<Node> a = nullptr;
        RefPtr<Node> b = nullptr;
        RefPtr<Node> c = nullptr;

        split(rt, v, a, b, false); // a < v, b >= v
        split(b, v, c, b, true);   // c == v, b > v

        if (c) {
            c->cnt++;
            pushUp(c);
        } else {
            c = newNode(v);
        }

        rt = merge(merge(a, c), b);
    }

    bool remove(int v) {
        RefPtr<Node> a = nullptr;
        RefPtr<Node> b = nullptr;
        RefPtr<Node> c = nullptr;

        split(rt, v, a, b, false); // a < v, b >= v
        split(b, v, c, b, true);   // c == v, b > v

        if (!c) {
            rt = merge(a, b);
            return false;
        }

        if (c->cnt > 1) {
            c->cnt--;
            pushUp(c);
        } else {
            auto del = c;
            c = merge(c->son[0], c->son[1]);

            del->son[0] = del->son[1] = nullptr;
            del->cnt = del->sz = 0;
        }

        rt = merge(merge(a, c), b);
        return true;
    }

    int find_rank(int v) {
        RefPtr<Node> a = nullptr;
        RefPtr<Node> b = nullptr;

        split(rt, v, a, b, false); // a < v, b >= v

        int ans = size(a) + 1;

        rt = merge(a, b);
        return ans;
    }

    int find_kth(int k) {
        if (!rt || k <= 0 || k > rt->sz) return -1;

        auto x = kth(rt, k);
        return x ? x->val : -1;
    }

    int find_prev(int v) {
        RefPtr<Node> a = nullptr;
        RefPtr<Node> b = nullptr;

        split(rt, v, a, b, false); // a < v, b >= v

        auto x = rightMost(a);
        int ans = x ? x->val : -1;

        rt = merge(a, b);
        return ans;
    }

    int find_next(int v) {
        RefPtr<Node> a = nullptr;
        RefPtr<Node> b = nullptr;

        split(rt, v, a, b, true); // a <= v, b > v

        auto x = leftMost(b);
        int ans = x ? x->val : -1;

        rt = merge(a, b);
        return ans;
    }
};

auto main() -> int {
    int T;
    std::cin >> T;

    FhqTreap treap;

    while (T--) {
        int op, x;
        std::cin >> op >> x;

        switch (op) {
            case 1:
                treap.insert(x);
                break;
            case 2:
                treap.remove(x);
                break;
            case 3:
                std::cout << treap.find_rank(x) << '\n';
                break;
            case 4:
                std::cout << treap.find_kth(x) << '\n';
                break;
            case 5:
                std::cout << treap.find_prev(x) << '\n';
                break;
            case 6:
                std::cout << treap.find_next(x) << '\n';
                break;
        }
    }

    return 0;
}

Template of Splay Tree

Sat, 09 May 2026 20:20:57 GMT

Security template of Splay Tree is coming~

#include <iostream>
#include <memory>
#include <vector>
#include <array>
#include <cassert>

template <typename Tp>
using OwnPtr = std::unique_ptr<Tp>;
template <typename Tp>
using RefPtr = Tp*;

class Splay {
private:
    struct Node {
        std::array<RefPtr<Node>, 2> son{nullptr, nullptr};
        RefPtr<Node> fat = nullptr;
        int cnt = 0, val = 0, sz = 0;
    };
    std::vector<OwnPtr<Node>> pool;

    auto dir(RefPtr<Node> x) -> int {
        assert(x && x->fat);
        return x == x->fat->son[1];
    }
    void pushUp(RefPtr<Node> x) {
        x->sz = x->cnt;
        if (x->son[0]) x->sz += x->son[0]->sz;
        if (x->son[1]) x->sz += x->son[1]->sz;
    }
    auto newNode(int v, RefPtr<Node> fat = nullptr) -> RefPtr<Node> {
        pool.push_back(std::make_unique<Node>());
        auto p = pool.back().get();
        p->fat = fat, p->val = v, p->cnt = p->sz = 1;
        return p;
    }

    void rotate(RefPtr<Node> x) {
        auto y = x->fat;
        auto z = y->fat;
        int r = dir(x);
        int d = z ? dir(y) : 0;
        y->son[r] = x->son[!r];
        if (x->son[!r]) x->son[!r]->fat = y;
        x->son[!r] = y;
        if (z) z->son[d] = x;
        else rt = x;
        y->fat = x;
        x->fat = z;
        pushUp(y);
        pushUp(x);
    }

    void splay(RefPtr<Node> x) {
        if (!x) return ;
        while (x->fat) {
            auto y = x->fat;
            auto z = y->fat;
            if (z) {
                if (dir(x) == dir(y)) rotate(y);
                else rotate(x);
            }
            rotate(x);
        }
        rt = x;
    }

    void find(int v) {
        auto x = rt;
        auto y = (RefPtr<Node>)nullptr;
        for (; x && x->val != v; y = x, x = x->son[v > x->val]);
        splay(x ? x : y);
    }

    void loc(int k) {
        auto x = rt;
        while (x) {
            int ls = x->son[0] ? x->son[0]->sz : 0;
            if (k <= ls) {
                x = x->son[0];
            } else if (k <= ls + x->cnt) {
                break;
            } else {
                k -= ls + x->cnt;
                x = x->son[1];
            }
        }
        if (x) splay(x);
    }

    auto merge(RefPtr<Node> x, RefPtr<Node> y) -> RefPtr<Node> {
        if (!x || !y) {
            if (x) return x;
            return y;
        }
        rt = y;
        loc(1);
        rt->son[0] = x;
        x->fat = rt;
        pushUp(rt);
        return rt;
    }

public:
    RefPtr<Node> rt = nullptr;

    Splay() = default;
    ~Splay() {
        clear();
    }
    void clear() {
        rt = nullptr;
        std::vector<OwnPtr<Node>>().swap(pool);
    }

    void insert(int v) {
        auto x = rt, y = static_cast<RefPtr<Node>>(nullptr);
        for (; x && x->val != v; y = x, x = x->son[v > x->val]);
        if (x) x->cnt++, x->sz++;
        else {
            x = newNode(v, y);
            if (y) y->son[v > y->val] = x;
            else rt = x;
        }
        splay(x);
    }

    bool remove(int v) {
        find(v);
        if (!rt || rt->val != v) return false;
        rt->cnt--, rt->sz--;
        if (!rt->cnt) {
            auto x = rt->son[0];
            auto y = rt->son[1];
            if (x) x->fat = nullptr;
            if (y) y->fat = nullptr;
            rt = merge(x, y);
        }
        return true;
    }

    int find_rank(int v) {
        find(v);
        if (!rt) return 1;
        return (rt->son[0] ? rt->son[0]->sz : 0) + (rt->val < v ? rt->cnt : 0) + 1;
    }

    int find_kth(int k) {
        if (!rt || k <= 0 || k > rt->sz) return -1;
        loc(k);
        return rt->val;
    }

    int find_prev(int v) {
        find(v);
        if (!rt) return -1;
        if (rt->val < v) return rt->val;
        auto x = rt->son[0];
        if (!x) return -1;
        for (; x->son[1]; x = x->son[1]);
        splay(x);
        return rt->val;
    }

    int find_next(int v) {
        find(v);
        if (!rt) return -1;
        if (rt->val > v) return rt->val;
        auto x = rt->son[1];
        if (!x) return -1;
        for (; x->son[0]; x = x->son[0]);
        splay(x);
        return rt->val;
    }
};

auto main() -> int {
    int T;
    std::cin >> T;
    Splay splay;
    while (T--) {
        int op, x;
        std::cin >> op >> x;
        switch (op) {
            case 1:
                splay.insert(x);
                break;
            case 2:
                splay.remove(x);
                break;
            case 3:
                std::cout << splay.find_rank(x) << '\n';
                break;
            case 4:
                std::cout << splay.find_kth(x) << '\n';
                break;
            case 5:
                std::cout << splay.find_prev(x) << '\n';
                break;
            case 6:
                std::cout << splay.find_next(x) << '\n';
                break;
        }
    }
    return 0;
}

Introduction of Splay

Fri, 08 May 2026 19:21:23 GMT

What is Splay Tree?

The most common two balance trees is Splay and Treap. I already have introduced treap before so this article let's learn Splay.

Unlike Treap, the basic operation of Splay is rotate. By rotating, we can let the node we want move to root. The core idea of Splay is using Splay function to let the node we recently visited depth get shallower.

What is its function?

It's a Balanced BST (Binary Search Tree), which can search, insert, delete a node in $O(\log n)$. And it can promise the tree balance.

Before explain the core operation Splay, You need know some basic sturcture and checking function.

Basic Structure

The example code in this article will using array to simulate pointer, the version more save will publish later.

Variable Name	Meaning
`rt`	Id of root
`id`	the quantity of used node
`fa[i]`	father of node $i$
`ch[i][0/1]`	left/right children of node $i$
`val[i]`	Value of node $i$
`cnt[v]`	The times value $v$ appear
`sz[i]`	The size of sub tree which root is $i$

Set all value to $0$ when initial.

Checking Function

bool dir(int x) {
    return x == ch[fa[x]][1]; // if x is left son return 0, or return 1.
}
void pushUp(int x) {
    sz[x] = cnt[x] + sz[ch[x][0]] + sz[ch[x][1]]; 
    // Update all information after changing position of node.
}

How to Rotate?

First we should know how the basic operation, rotate work.

This image told us how to rotate node $x$ in a tree. It's not difficlut to find that the inorder traversal of this tree have no changes. So rotate can not change the BST property of Splay tree. And it also a way to maintain the time complexity (or length) of Splay tree.

void rotate(int x) {
    int y = fa[x], z = fa[y];
    bool r = dir(x);
    ch[y][r] = ch[x][!r];
    ch[x][!r] = y;
    if (z) ch[z][dir(y)] = x;
    if (ch[y][r]) fa[ch[y][r]] = y;
    fa[y] = x;
    fa[x] = z;
    push_up(y);
    push_up(x);
}

Observe the picture I drawed can understand this function.

How to Splay?

Then, many rotate operation become a splay operation. There are some basic model when doing splay : Zig, Zig-Zig, Zig-Zag.

We define function Splay(x, k) denotes let node $x$ move up until be son of node $k$.

Without thinking, do nothing if $x = k$.

Zig

This situation when $x$ is son of $k$. Just rotate $x$ is okay.

In splay tree, we only do left rotate operation when $x$ is right son, and only do right rotate operation when $x$ is left son. That can lead us using one function to realize Splay(x,k) in code.

Zig-Zig

This situation when $x$ and $fa_x$ is son in same side of their father. We should first rotate $fa_x$ then rotate $x$, we can do a little contrast.

Why not rotate $x$ twice? That because it will change the relative position of $fa_x$ and $x$. Using correct Zig-Zig plan can let the final struction also Zig-Zig, and this plan also get best time complexity when potential method

Zig-Zag

This situation when $x$ and $fa_x$ is son in different side of their father. We can rotate $x$ twice in this situation.

We can found the height of this tree decrease.

Code

Then we know all the operator in each situation we can write the code:

void splay(int& z, int x) {
    int w = fa[z];
    for (int y; (y = fa[x]) != w; rotate(x)) { // whatever which situation, the last operation is rotate x
        if (fa[y] != w)  // if zigzig or zigzag
            rotate(dir(x) == dir(y) ? y : x); // check it's zigzig or zigzag
    }
    z = x;
}

How Splay Tree Do Basic Operation of Balance Tree?

And below is how splay to realize some classic operation.

Find with Value

Because Splay Tree also a BST, so the process find a node with value is same as BST, a only difference is we need splay node we found to root.

// find value v; if not found, end at last accessed node
void find(int& z, int v) {
    int x = z, y = 0; // x: current node, y: last visited node
    for (; x && val[x] != v; x = ch[y = x][v > val[x]]);
    // traverse BST; stop when found or reach null
    splay(z, x ? x : y);
    // splay the found node, or the last accessed node to root
}

Find with Rank

Same as treap too.

void loc(int& z, int k) {
    int x = z;
    for (;;) {
        if (sz[ch[x][0]] >= k) {
            x = ch[x][0];
        } else if (sz[ch[x][0]] + cnt[x] >= k) {
            break; 
        } else {
            k -= sz[ch[x][0]] + cnt[x];
            x = ch[x][1];
        }
    }
    splay(z, x);
}

Insert a Value

void insert(int v) { // insert value v
    int x = rt, y = 0;
    for (; x && val[x] != v; x = ch[y = x][v > val[x]]);
    // find a node with value 
    if (x) { // if already have this node (isn't empty node & value is wanted)
        ++cnt[x];
        ++sz[x];
    } else { // is a empty node
        x = ++id; // new node & initialize
        val[x] = v;
        cnt[x] = sz[x] = 1;
        fa[x] = y;
        if (y) ch[y][v > val[y]] = x; // insert it
    }
    splay(rt, x); // splay it to root
}

Merge Two Slay Trees

This operation really like treap.

int merge(int x, int y) {
    if (!x || !y) return x | y;
    loc(y, 1); // find the minimum of tree y, it must have no left children
    ch[y][0] = x;
    fa[x] = y;
    push_up(y);
    return y; // return now root
}

Remove a Value

bool remove(int v) {
    find(rt, v);
    if (!rt || val[rt] != v) return false;
    --cnt[rt];
    --sz[rt];
    if (!cnt[rt]) {
        int x = ch[rt][0];
        int y = ch[rt][1];
        fa[x] = fa[y] = 0;
        rt = merge(x, y);
    }
    return true;
}

Query Rank

int find_rank(int v) {
    find(rt, v); // we cannot sure result find returned must greater or less than v when v is not exist
    return sz[ch[rt][0]] + (val[rt] < v ? cnt[rt] : 0) + 1;
}

Query Prevent and Next

int find_prev(int v) {
    find(rt, v); // rt exist and val[rt] less than v
    if (rt && val[rt] < v) return val[rt];
    int x = ch[rt][0]; // this situation when v exist or have a node which greater than v
    if (!x) return -1; // so check now node's left subtree
    for (; ch[x][1]; x = ch[x][1]); // the maximum of left subtree is rightest node
    splay(rt, x);
    return val[rt];
}

// same with find_prev
int find_next(int v) {
    find(rt, v);
    if (rt && val[rt] > v) return val[rt];
    int x = ch[rt][1];
    if (!x) return -1;
    for (; ch[x][0]; x = ch[x][0]);
    splay(rt, x);
    return val[rt];
}

All Code

From OI wiki.

#include <iostream>

constexpr int N = 2e6;
int id, rt;
int fa[N], val[N], cnt[N], sz[N], ch[N][2];

bool dir(int x) { return x == ch[fa[x]][1]; }

void push_up(int x) { sz[x] = cnt[x] + sz[ch[x][0]] + sz[ch[x][1]]; }

void rotate(int x) {
  int y = fa[x], z = fa[y];
  bool r = dir(x);
  ch[y][r] = ch[x][!r];
  ch[x][!r] = y;
  if (z) ch[z][dir(y)] = x;
  if (ch[y][r]) fa[ch[y][r]] = y;
  fa[y] = x;
  fa[x] = z;
  push_up(y);
  push_up(x);
}

void splay(int& z, int x) {
  int w = fa[z];
  for (int y; (y = fa[x]) != w; rotate(x)) {
    if (fa[y] != w) rotate(dir(x) == dir(y) ? y : x);
  }
  z = x;
}

void find(int& z, int v) {
  int x = z, y = fa[x];
  for (; x && val[x] != v; x = ch[y = x][v > val[x]]);
  splay(z, x ? x : y);
}

void loc(int& z, int k) {
  int x = z;
  for (;;) {
    if (sz[ch[x][0]] >= k) {
      x = ch[x][0];
    } else if (sz[ch[x][0]] + cnt[x] >= k) {
      break;
    } else {
      k -= sz[ch[x][0]] + cnt[x];
      x = ch[x][1];
    }
  }
  splay(z, x);
}

int merge(int x, int y) {
  if (!x || !y) return x | y;
  loc(y, 1);
  ch[y][0] = x;
  fa[x] = y;
  push_up(y);
  return y;
}

void insert(int v) {
  int x = rt, y = 0;
  for (; x && val[x] != v; x = ch[y = x][v > val[x]]);
  if (x) {
    ++cnt[x];
    ++sz[x];
  } else {
    x = ++id;
    val[x] = v;
    cnt[x] = sz[x] = 1;
    fa[x] = y;
    if (y) ch[y][v > val[y]] = x;
  }
  splay(rt, x);
}

bool remove(int v) {
  find(rt, v);
  if (!rt || val[rt] != v) return false;
  --cnt[rt];
  --sz[rt];
  if (!cnt[rt]) {
    int x = ch[rt][0];
    int y = ch[rt][1];
    fa[x] = fa[y] = 0;
    rt = merge(x, y);
  }
  return true;
}

int find_rank(int v) {
  find(rt, v);
  return sz[ch[rt][0]] + (val[rt] < v ? cnt[rt] : 0) + 1;
}

int find_kth(int k) {
  if (k > sz[rt]) return -1;
  loc(rt, k);
  return val[rt];
}

int find_prev(int v) {
  find(rt, v);
  if (rt && val[rt] < v) return val[rt];
  int x = ch[rt][0];
  if (!x) return -1;
  for (; ch[x][1]; x = ch[x][1]);
  splay(rt, x);
  return val[rt];
}

int find_next(int v) {
  find(rt, v);
  if (rt && val[rt] > v) return val[rt];
  int x = ch[rt][1];
  if (!x) return -1;
  for (; ch[x][0]; x = ch[x][0]);
  splay(rt, x);
  return val[rt];
}

int main() {
  int n;
  std::cin >> n;
  for (; n; --n) {
    int op, x;
    std::cin >> op >> x;
    switch (op) {
      case 1:
        insert(x);
        break;
      case 2:
        remove(x);
        break;
      case 3:
        std::cout << find_rank(x) << '\n';
        break;
      case 4:
        std::cout << find_kth(x) << '\n';
        break;
      case 5:
        std::cout << find_prev(x) << '\n';
        break;
      case 6:
        std::cout << find_next(x) << '\n';
        break;
    }
  }
  return 0;
}

Solution Report of String(Middle) Topic

Wed, 29 Apr 2026 21:06:35 GMT

P12923 [POI 2021/2022 R3] 模板 2 / Szablon 2

You can found that if a chain of expanding just contribute length less than half, they all can be replaced by the last one.

Then we can using ExKMP to calculate the LCP of origin string and adverse string, knowing that which place should not place string.

The last part we can greedy, the strategy is find the most back position which can compare a origin string or adverse string, it is easy. But there I know a new way to maintain this position which is using DSU instead SegTree.

At first each node point to themselves. Then if note $x$ become invalid, let fa[x] = find(x-1). So the root of each DSU is the most back position which valid.

P11291 【MX-S6-T3】「KDOI-11」简单的字符串问题 2

P10716 【MX-X1-T4】「KDOI-05」简单的字符串问题

We can prove that a string A is valid if and only if:

A is a border of S[1..i];
A appears at least k times in S[1..i] without overlap.

After building the failure tree, we can observe that all valid A form a chain from some node u to the root, and u is an ancestor of i. Therefore, once we know u, the answer is simply dep[u].

We can find u using binary lifting.
This is equivalent to checking the following condition:

So we preprocess, for every prefix S[1..u], the positions where this string appears in the whole string without overlap. This is equivalent to repeatedly finding the first suffix after the current position whose LCP with S is at least u, and then jumping to that suffix.

The total number of jumps is at most:

$$ \sum_{i=1}^{n} \frac{n}{i} = O(n \log n) $$

so we can just simulate the jumps directly.

To compute the LCP between a suffix and S, we can use the Z-function.
Then we apply the DSU trick to maintain a linked list: enumerate u from small to large, and after finishing u, delete all positions p with z[p] = u. This guarantees that when processing u, the DSU representative of a position is exactly the next position with z[p] \ge u.

In this way, we can find in O(\alpha(n)) the first position p after a given index such that z[p] ≥ u.

Note that the case k = 1 needs to be handled separately.

Thus the total time complexity is:

$$ O(q \log n + n \alpha(n) \log n) $$

P9482 [NOI2023] 字符串

P6125 [JSOI2009] 有趣的游戏

It's not hard to think of using ACAM to solve this problem. But the difficlut point is if the state denote probability when through a node on ACAM, but ACAM have cycle so we cannot use it.

Consider below things: We stop when across a mark point on ACAM, so we can let state to calculate expectation. Because we stop when meet first mark point, so we can promise the sum of expectation of each node equal to $1$. Expectation now is equal to probability.

Left part is easy, just use gaussian elimination solve it.

P5466 [PKUSC2018] 神仙的游戏

We found that if a string $s$ have a border length $len$, it will have a cyclic section with length $n-len$. So wildcard become meanless because we can calculate them by cyclic section.

To be more, if $i$ and $j$ are equal modulo $n-len$, $s_i$ and $s_j$ are must equal, or $len$ is impossible.

So we can define two array:

$a[i]$, it will equal $1$ only when $s[i]$ is equal $1$.
$b[i]$, it will equal $1$ only when $s[i]$ is equal $0$.

Then we can use

$$ C[d] = \sum_{i=1}^n A[i]\times B[i+d] $$

to count there are different number pair in length $d$.

left part is easy, just check a length $len$ is valid or not then add it contribution to answer.

P4569 [BJWC2011] 禁忌

The optimal strategy is greedy.

Suppose we have already matched a taboo string ending at position i.

If we cut immediately, we gain +1, and restart.
If we delay, this segment may overlap with future matches, possibly reducing total count.

Thus: Cut immediately whenever a taboo string appears is optimal.

We build an AC Automaton over all taboo strings.

Each state represents:

current suffix match
whether we have matched a taboo string (is_taboo)

And do is_taboo[u] |= is_taboo[fail[u]]. So any suffix match is correctly detected.

Let:

state denotes current node in AC automaton
plus one extra dimension: accumulated expectation

So total dimension is states + 1

Since the string is random, each character is chosen with probability 1 / alphabet.

Enumerate (u, c), let v = next(u, c).

If v is not taboo, just transfer u → v.
If v is taboo, we greedily cut here, so u → root and contribute +1.

To handle expectation, add one extra dimension ans_col.
When hitting a taboo, do trans[u][ans_col] += 1 / alphabet and let trans[ans_col][ans_col] = 1 so the answer accumulates.

Now the whole process becomes a linear transfer:

$$ f_{t+1} = f_t × trans $$

We need exactly length len, so compute trans^len

Starting from root, the answer is (trans^len)[root][ans_col].
Time complexity is $O(S^3 log len)$ where $S$ is number of AC states.

P4081 [USACO17DEC] Standing Out from the Herd P

There is common trick when SA is solving a problem with lot of string. Let these string end to end, and using a character which not in character set to connect them.

Let the initial answer equal to $\frac{len\times(len+1)}{2}$.

For each suffix $x$, the excluded answer is $\max(\operatorname{lcp}(x,i),\operatorname{lcp}(x,j),\operatorname{lcp}(x,k))$, where $i$ is the suffix with the largest rank satisfying $rk[i]<rk[x], id[i]\neq id[x]$, $j$ is the suffix with the smallest rank satisfying $rk[j]>rk[x], id[j]\neq id[x]$, and $k$ is the suffix with the largest rank satisfying $id[k]=id[x]$.

Then we can find hight array in SA is equal to excluded part. So just minus them.

P4465 [国家集训队] JZPSTR

It said that std of this problem is Unrolled Linked List + SAM, but most solution in Luogu using bitset to solve it and get a great score.

Because the character set is little just 10, we let std::bitset<N> b[x] denote character $x$ is at $pos$ if b[x][pos] = 1. Then we can maintain each oeprate easily.

right move origin string length of $y_i$ from $x_i$, then put $y_i$ in the blank.
same with above, left move origin string length of $y_i - x_i + 1$.

Then how to match a string become the main problem. Repeat ans = (ans << 1) & b[z[j]-'0'] then the number of $1$ is answer, draw the process then you can understand, this algorithm called Shift-and.

P4045 [JSOI2009] 密码

Classic problem, do compression DP on ACAM.

Let dp[i][j][msk] denotes when we contract to place $i$ and we are on the node $j$ ACAM and the usage state of preparing string is $msk$. Then transition is easy.

$$ dp[i][j][msk] \rightarrow dp[i+1][tr_{j,l}][msk|state_{tr_{j,l}}] $$

$tr_{j,l}$ denotes the son of node $j$ which is meaning letter $l$.

The answer is sum of $dp[n][j][fullmask]$.

P3823 [NOI2017] 蚯蚓排队

Becasue $k$ is very little, we can maintain answer of each $k$ when hashtable is merging and splitting.

We can maintain this queue by list, and answer only related to $k$. For example, if we are merging two queue, just enumerate the length $l$ and enumerate start point $j$ then count all string that two endpoints are on both sides of the splice.

The time complexity is $O(nk + ck^2 + \sum |s|)$, $c$ is the number of second operation. Because each operate will just produce $k^2$ hash value at most.

P1117 [NOI2016] 优秀的拆分

P3234 [HNOI2014] 抄卡组

Analyze in 3 cases.

All string have no *, compare them with hash.
All string have *, check substring from 0 to first * is prefix of next string, and the substring from last * to end is suffix of next string. Remember sort with length.
Both two case. First, check same as case 1. Then we can use hash check beginning, middle, ending part of this string.

P3715 [BJOI2017] 魔法咒语

Also a classic problem, similar as P4045 but this problem should split into two part to solve it.

First for small $L$, do compress DP on ACAM, the state $dp[len][j]$ denotes we already get new magic which length is $len$ and we are at node $j$ on ACAM. Transition is easy. Enumerate all string if there are no bad word, we can transition.

Then try think how to solve this problem when $L <= 10^8$, first we can know that we must use matrix multiple to solve it when $L$ become such so big. So we have below idea:

$$ \left[\begin{matrix} F_t \ F_{t+1} \end{matrix}\right]

\operatorname{Matrix} \times \left[\begin{matrix} F_{t-1} \ F_{t} \end{matrix}\right] $$

Then their is a common trick when construct matrix: if $i$ can transition to $j$, mat[i][j]++.
Same as first case, transition is easy, then we can get transition matrix.

P3245 [HNOI2016] 大数

We using $sum[i]$ denotes the value of $S[i\dots n]$.

Also we can analyze into $2$ cases: $P$ equal or not equal to $2$ and $5$.

If is not:

$$ \begin{aligned} &\ \frac{sum[L] - sum[R+1]}{10^{n-R}} \bmod P = 0\ \Rightarrow &\ (sum[L] - sum[R+1]) \bmod P = 0 \ \Rightarrow &\ sum[L] \equiv sum[R+1] \pmod{P} \ \end{aligned} $$

Then problem turn to count how many same number in $sum[L\dots R+1]$, it a classic problem of Mo's algorithm.

If is:

It become easier: if the end of a number can be divided by $2$ or $5$ then whole number can be divided by it, so answer increase $i$ if $a[i] \bmod P = 0$.

P3546 [POI 2012] PRE-Prefixuffix

Because of the length-$L$ prefix and suffix can be represented as XY and YX, if we using $k$ denote the cut position between $X$ and $Y$. Then we have : $s[1\cdots k]=s[n-k+1\cdots n],s[k+1\cdots L]=s[n-L+1\cdots n-k]$. This means that problem wants to us calculate two borders.

then is a interesting transition: turn origin string into form $s_1,s_n,s_2,s_{n-1},\cdots$, two borders problem let we calculate become two palindromes on top. So using manacher can solve this problem easily.

P3454 [POI 2007] OSI-Axes of Symmetry

If a shape is symmetrical, we can get a palindrome if cut from a endpoint of axis of symmetry.

So use cross product instead of angle, the square of an edge's length instead of length of edge. Then manacher to count how many palindrome can cover a length $n$ substring in the double-string. double-string means we paste a copy of origin string at the end of origin string.

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 最小表示法

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

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] 字符串匹配

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] 通配符匹配

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

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:

Construct Idea:

Prove: Why it is 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.

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

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.

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.

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.

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} $$

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.

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.