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

lca.cpp

// 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];
}

CONTIGUITAS

Physical memory contiguity

Linux vs. Contiguitas physical address space. Linux scatters unmovable pages (gray) across memory, leaving only short runs of contiguity; Contiguitas confines them to one end and wins back one large run.

One unmovable page inside a 2 MB block is enough to poison the whole block. Contiguitas wins the space back by not scattering those pages in the first place.

1
ConfinementUnmovable pages are allocated only inside a dedicated region, never mixed into the movable pool.
2
Dynamic resizingThe boundary between the two regions grows and shrinks with memory pressure.
3
Hardware migrationHardware moves unmovable pages from Src to Dst — no software in the loop. Dropped for xv6, which has no live-device pages.

Read the xv6 implementation

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.

// Competitive Programming
#include <bits/stdc++.h>
using namespace std;

int main() {
    auto solve = [&]() {
        // think deeply
        // code carefully
    };
    ios::sync_with_stdio(false);
    int t; cin >> t;
    while (t--) solve();
}

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.

/* Trunk Trick */
master the trunk first
then the tricks follow

struct Insight {
    // Core understanding
    int depth, clarity;
};

struct Trick : Insight {
    // Clever optimization
    auto apply() { ... }
};

8+ Blog Posts

50+ Algorithm Articles

3 Interactive Tools

// Network Flow // Planar Graphs // Disjoint Set Union // Binary Lifting // Dynamic Programming // Number Theory // Computational Geometry // Graph Algorithms // Network Flow // Planar Graphs // Disjoint Set Union // Binary Lifting // Dynamic Programming // Number Theory // Computational Geometry // Graph Algorithms

∑ π λ ∞ ⊆ → ∈ ∀

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.

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.