Trunk Trick

An undergraduate at Xi'an Jiaotong University, an independent developer, and a competitive programmer obsessed with the craft of algorithms.

From number theory to graph theory, from data structures to dynamic programming — this is where I document every "aha!" moment along the journey. Built slowly, written carefully.

Read the Blog Explore AlgoLab GitHub

// Lowest Common Ancestor
int lca(int u, int v) {
    if (depth[u] < depth[v]) swap(u, v);
    int diff = depth[u] - depth[v];
    for (int i = 0; diff; i++, diff >>= 1)
        if (diff & 1) u = up[u][i];
    if (u == v) return u;
    for (int i = LOG-1; i >= 0; i--)
        if (up[u][i] != up[v][i])
            u = up[u][i], v = up[v][i];
    return up[u][0];
}

Interactive

Branch & Bound on TSP

Reduced Matrix of parent (V1)

∞10068 0∞090 40∞812 851∞0 01160∞

→

Pick edge
V1 → V2
Discard row/col

Initial Matrix of child

∞090 4∞812 81∞0 060∞

→

Row & col
reduction

Reduced Matrix of child

∞090 0∞48 81∞0 060∞

Global base cost
Parent's reduced cost (12)

Extra cost of chosen edge
Edge V1→V2 weight (10)

Minimum additional cost
Child matrix re-reduction (4+0)

lb = lb(parent) + w(V1→V2) + child.reduced = 12 + 10 + 4 = 26

Ready — click Expand

ABOUT THE AUTHOR

Algorithm enthusiast & independent developer

I'm an undergraduate at Xi'an Jiaotong University (XJTU), pursuing a deep understanding of algorithms, systems, and the principles behind computation. As an independent developer, I build tools and write about the things I learn — from competitive programming tricks to operating system internals.

This site is my public notebook. Every article, every visualization, and every line of code here represents a question I once asked myself and the answer I eventually found — or built from scratch.

ABOUT TRUNK TRICK

Master the trunk, then the tricks

The name comes from a simple metaphor: every complex algorithmic technique is like a tree — its trunk is the core insight, and the tricks are the clever optimizations that make it work in practice. Master the trunk first, then the tricks will follow.

Here you'll find deep dives into graph algorithms, network flow, dynamic programming, computational geometry, and more — written not as dry reference material, but as stories of exploration and discovery.

∑ π λ ∞ ⊆ → ∈ ∀

TOPICS

Topics I Write About

Every topic here comes from real problems I've encountered. The visualizations are my way of making abstract ideas concrete.

Graph Theory · Network Flow

Max Flow Modeling

How do you determine whether a sports team is mathematically eliminated from the playoffs? The answer is a maximum flow network — source nodes representing remaining games, team nodes with carefully chosen capacities, and a sink that reveals the truth.

Graph Theory · Planarity

Planar Graphs & Kuratowski's Theorem

Which graphs can be drawn on a plane without crossing edges? From Euler's formula $V - E + F = 2$ to the forbidden subgraphs $K_5$ and $K_{3,3}$, planarity theory sits at the intersection of discrete mathematics, topology, and computational geometry.

// Disjoint Set Union
int find(int x) {
    return p[x] == x ? x : p[x] = find(p[x]);
}
void unite(int a, int b) {
    a = find(a), b = find(b);
    if (a != b) {
        if (sz[a] < sz[b]) swap(a, b);
        p[b] = a; sz[a] += sz[b];
    }
}

Data Structures · DSU

Disjoint Set Union & Path Compression

The Union-Find data structure with path compression achieves nearly $O(1)$ amortized time per operation. Deceptively simple — just a few lines of code — yet it's the backbone of Kruskal's MST, dynamic connectivity, and countless competitive programming solutions.

EXPLORE

What you'll find here

Algorithms

Number theory, graph algorithms, DP, data structures. 50+ articles with interactive visuals.

Blog

Contest writeups, debugging stories, and notes on building things from scratch.

Visual Tools

FFT visualizer, pathfinding sandbox, and a 3D graph galaxy. Learn by seeing.

Interactive