Survey on CuriousCoding

Range Minimum Queries

Mon, 11 May 2026 00:00:00 +0200

Table of Contents

1 Naive
- 1.1 Compute on-the-fly
- 1.2 Precompute everything
2 Space lower bounds
3 Sparse Table: $O(1)$ queries, $O(n \log_2 n)$ words
4 Segment Tree: $O(\log n)$ queries, $O(n)$ words
5 Blocks: $O(s)$ queries, $O(n/s \log n)$ words
6 Cartesian Trees: $O(1)$ queries, $O(n)$ words
7 Recursive Cartesian Trees: $O(1)$ queries, $2n+o(n)$ bits
8 Blackboard

\[ \DeclareMathOperator*{\argmin}{arg\,min} \newcommand{\rmq}{\mathsf{rmq}} \]

These notes are based on slides by Florian Kurpicz and the paper by Fischer and Heun (2011) that introduces a number of optimal implementations.

Wheeler graphs

Thu, 26 Feb 2026 00:00:00 +0100

Table of Contents

1 Deterministic Finite Automaton (DFA)
2 Wheeler-DFA
3 Linear graphs: Prefix array
4 De Bruijn graphs are Wheeler
5 Not all DFAs are Wheeler
6 Locating patterns via binary search
7 Locating patterns via the BOSS table

These are some notes on Wheeler DFAs after chatting with Nicola Prezza¹ and others from the RAVEN lab at DSB 2026 in Venice.

1 Deterministic Finite Automaton (DFA) Link to heading

A DFA is a graph where edges are labelled by characters. Each node can have at most one outgoing edge with each label. (Otherwise it would be non-deterministic.)

Overview of static data structures

Wed, 17 Dec 2025 00:00:00 +0100

Table of Contents

1 Classification of static data structures
2 Space lower bounds and practical approaches
- 2.1 Rank
- 2.2 Rank + Select
- 2.3 Minimal perfect hash function (MPHF)
- 2.4 TODO Monotone MPHF
- 2.5 TODO Order-preserving MPHF
- 2.6 Static retrieval: Static function with static values
- 2.7 Updatable retrieval: Static function with mutable values
- 2.8 Static set (membership)
- 2.9 Static ordered set
- 2.10 Static dictionary: static keys and values
- 2.11 Updatable dictionary with mutable values
- 2.12 TODO Dynamic dictionary with mutable keys and values
- 2.13 TODO Static filter
- 2.14 TODO Ordered static/updatable/dynamic dictionary?
3 Summary table

\[ \newcommand{\K}{\mathbb K} \newcommand{\V}{\mathbb V} \newcommand{\c}[1]{\mathbf{\mathsf{#1}}} \]

A History of Pairwise Alignment

Wed, 09 Apr 2025 00:00:00 +0200

Table of Contents

1 A Brief History
- 1.1 A*PA
- 1.2 A*PA2
- 1.3 Overview
2 Problem Statement
3 Alignment types
4 Cost Models
- 4.1 Minimizing Cost versus Maximizing Score
5 The Classic DP Algorithms
6 Linear Memory using Divide and Conquer
7 Dijkstra’s Algorithm and A*
8 Computational Volumes and Band Doubling
9 Diagonal Transition
10 Parallelism
11 LCS and Contours
12 Some Tools
13 Subquadratic Methods and Lower Bounds
14 Summary

This is Chapter 2 of my thesis (Groot Koerkamp 2025), to introduce the first part on Pairwise Alignment. Please cite the thesis instead of this post.

Low Density Minimizers

Tue, 08 Apr 2025 00:00:00 +0200

Table of Contents

1 Theory of Sampling Schemes
- 1.1 Introduction
- 1.2 Overview
- 1.3 Theory of sampling schemes
- 1.4 Notation
- 1.5 Types of sampling schemes
- 1.6 Computing the density
- 1.7 The density of random minimizers
- 1.8 Universal hitting sets
- 1.9 Asymptotic results
- 1.10 Variants
2 Lower Bounds on Sampling Scheme Density
3 Practical Sampling Schemes
- 3.1 Variants of lexicographic minimizers
  - Evaluation
- 3.2 UHS-inspired schemes
- 3.3 Syncmer-based schemes
- 3.4 Open-closed minimizer
  - Evaluation
- 3.5 Mod-minimizer
  - Theoretical density
  - Evaluation
- 3.6 Discussion
4 Towards Optimal Selection Schemes
- 4.1 Bidirectional anchors
- 4.2 Sus-anchors
  - Evaluation
- 4.3 Discussion

This is Part 2 of my thesis (Groot Koerkamp 2025), containing chapters 6 to 9 on Low Density Minimizers. Please cite the thesis instead of this post.

SimdSketch: a fast bucket sketch

Sun, 09 Mar 2025 00:00:00 +0100

Table of Contents

1 Jaccard similarity
2 Hash schemes
- 2.1 MinHash
- 2.2 $s$-mins sketch
- 2.3 Bottom-$s$ sketch
- 2.4 FracMinHash
- 2.5 Bucket sketch
- 2.6 Mod-bucket hash (new?)
- 2.7 Variants
3 Compressing sketches
- 3.1 $b$-bit hashing
  - 3.1.1 Accounting for collisions
- 3.2 HyperMinHash
4 Densification strategies
5 SimdSketch
6 Evaluation
- 6.1 Setup
  - 6.1.1 Tools
  - 6.1.2 Inputs
  - 6.1.3 Parameters
  - 6.1.4 Metrics
- 6.2 Raw results
- 6.3 Correlation
- 6.4 Comparison speed
- 6.5 Low-similarity data
7 Discussion
8 TODO / Future work

\[ \newcommand{\sketch}{\mathsf{sketch}} \]

Types of tigs

Sun, 09 Mar 2025 00:00:00 +0100

1 De Bruijn graph Link to heading

Consider an edge-centric De Bruijn graph, where each edge corresponds to a k-mer, and nodes are the $k-1$ overlaps between adjacent k-mers. In the figures, all edges are directed towards the right.

2 k-mers Link to heading

The goal is now to store all edges / k-mers of the graph efficiently. A spectrum preserving string set (SPSS) is a set of strings whose k-mers are the k-mers of the input graph, that does not contain duplicate k-mers (Rahman and Medvedev 2020).

Minimizer papers

Mon, 17 Feb 2025 00:00:00 +0100

Table of Contents

1 Overview
2 Introduction - Previous reviews
3 Theory of sampling schemes
- 3.1 Questions
- 3.2 Types of schemes
- 3.3 Parameter regimes
- 3.4 Different perspectives
- 3.5 UHS vs minimizer scheme
- 3.6 (Asymptotic) bounds
- 3.7 Lower bounds
4 Minimizer schemes
- 4.1 Orders
- 4.2 UHS-based and search-based schemes
- 4.3 Pure schemes
- 4.4 Other variants
  - Selection schemes
  - Canonical minimizers
- 4.5 Non-overlapping string sets

This post is simply a list of brief comments on many papers related to minimizers, and forms the basis of /posts/minimizers/.

FM-index implementations

Wed, 02 Oct 2024 00:00:00 +0200

Table of Contents

A note on SDSL versions

Here I’ll briefly list some FM-index and related implementations around the web. Implementations seem relatively inconsistent, mostly because the FM-index is more of a ‘wrapper’ type around a given Burrows-Wheeler-transform and an occurrences list implementation. Both can be implemented in various ways. In particular occurrences should be stored using a wavelet tree for optimal compression.

The nucleic-acid repo contains a completely unoptimised version.
The Rust-bio crate contains a generic FM-index. It stores a sampled occurrences array, so that space is relatively small but lookups take $O(k)$ time for sampling factor $k$.
SDSL-lite contains a wavelet tree and compressed suffix array implementation based on it, that provides the same functionality as an FM-index.
There is the Quad Wavelet Tree (QWT) Rust crate (Ceregini, Kurpicz, and Venturini 2024). This uses a 4-ary tree instead of the usual binary wavelet tree, and improves latency by around a factor 2 over SDSL wavelet trees.
Dominik Kempa has the Faster-Minuter index (Gog et al. 2019) that contains an improved wavelet tree as well.
GEM-Cutter contain a GPU implementation of the FM-index (Chacon et al. 2015).
There is also RopeBWT3 (Li 2024), which is basically a run-length compressed BWT with a B+ tree on top for fast queries.
AWRY

A note on SDSL versions Link to heading

github:simongog/sdsl is the original, with last commit in 2013.
github:simongog/sdsl-lite is v2, with last commit in 2019, and seems the most used currently.
github:xxsds/sdsl-lite is v3 and seems to be actively maintained at the time of writing (Jan 2025), and is recommended by the original developers. From a quick glance, I think it’s somewhat restructured and truly a v3, not just a v2.1. However, it seems to be much less popular.
github:vgteam/sdsl-lite is a fork of the original sdsl-lite, with, I think, a number of small bug fixes and some updates for recent compiler versions.

Then there are also some rust versions:

PACE 24

Thu, 05 Sep 2024 00:00:00 +0200

Table of Contents

1 General observations
2 Heuristic track
3 Parameterized track
4 Exact track

In this post I will collect some high level ideas and approaches used to solve the PACE 2024 challenge. Very briefly, the goal is to write fast solvers for NP-hard problems. The problem for the 2024 edition is one-side crossing minimization: Given is a bipartite graph $(A, B)$ that is drawn in standard way with the nodes of both $A$ and $B$ on a line, where the order of the nodes of $A$ is fixed. The goal is to find a permutation of $B$ that minimizes the number of edge crossings when all edges are drawn as straight lines.

Tools for suffix array searching

Fri, 14 Jun 2024 00:00:00 +0200

Table of Contents

1 Sapling
2 PLA-Index
3 LISA: learned index

Let’s summarize some tools for efficiently searching suffix arrays.

1 Sapling Link to heading

Sapling (Kirsche, Das, and Schatz 2020) works as follows:

Choose a parameter $p$ store for each of the $2^p$ $p$-bit prefixes the corresponding position in the suffix array.
When querying, first find the bucket for the query prefix. Then do a linear interpolation inside the bucket.
Search the area $[-E, +E]$ around the interpolated position, where $E$ is a bound on the error of the linear approximation. In practice $E$ is only a $95\%$-confidence bound, and if the true value is not in the range, a linear search with steps of size $E$ is done.

The paper also introduces a neural network approach to approximating buckets, but this takes over a day to learn and is slower to query in practice.

Crates for suffix array construction

Thu, 13 Jun 2024 00:00:00 +0200

Popular C libraries are:

Both have a ..64 variant that supports input strings longer than 2GB.

Rust wrappers:

divsufsort: rust reimplementation, does not support large inputs.
cdivsufsort: c-wrapper, does not support large inputs
livdivsufsort-rs: c-wrapper, does support large inputs
sais: unrelated to the original library; does not implement a linear time algorithm anyway
libsais-rs: Daniel Liu’s fork-of-fork of the original, but not on crates.io. Supports multithreading using OpenMP and wraps both the original and 64bit version.
simple-saca: Daniel Liu’s bounded-context suffix array construction that is faster than divsufsort and libsais, but does not return a true fully sorted suffix array.

References Link to heading

Mod-minimizers and other minimizers

Thu, 18 Jan 2024 00:00:00 +0100

\[ \newcommand{\d}{\mathrm{d}} \newcommand{\L}{\mathcal{L}} \]

This post introduces some background for minimizers and some experiments for a new minimizer variant. That new variant is now called the mod-minimizer and published at WABI24 (DOI, PDF) (Groot Koerkamp and Pibiri 2024). The paper also includes a review of existing methods, including pseudocode for most of the methods covered below.

Shortest paths, bucket queues, and A* on the edit graph

Sat, 29 Jul 2023 00:00:00 +0200

Table of Contents

Shortest path algorithms ..
- .. in general
- .. for circuit design
Bucket queues
Shortest path algorithms by Hadlock
- Grid graphs
- Strings
Spouge’s computational volumes

This note summarizes some papers I was reading while investigating the history of A* for pairwise alignment, and related to that the first usage of a bucket queue. Schrijver (2012) provides a nice overview of general shortest path methods.

The complexity and performance of WFA and band doubling

Thu, 17 Nov 2022 00:00:00 +0100

Table of Contents

Complexity analysis
Implementation efficiency
- Band doubling for affine scores was never implemented
WFA vs band doubling for affine costs
Conclusion
- Future work

This note explores the complexity and performance of band doubling (Edlib) and WFA under varying cost models.

Edlib (Šošić and Šikić 2017) uses band doubling and runs in $O(ns)$ time, for sequence length $n$ and edit distance $s$ between the two sequences.

Bidirectional A*

Thu, 28 Jul 2022 17:59:00 +0200

These are some links and papers on bidirectional A* variants. Nothing insightful at the moment.

small lecture: introduces $h_f(u) = \frac 12 (\pi_f(u) - \pi_r)$. Not found a paper yet.
An Improved Bidirectional Heuristic Search Algorithm (Champeaux 1977): introduces a bidirectional variant
Bidirectional Heuristic Search Again (Champeaux 1983): fixes a bug in the above paper
Efficient modified bidirectional A* algorithm for optimal route-finding: Didn’t read closely yet.
A new bidirectional algorithm for shortest paths (Pijls 2008): Actually a new methods. Seems to cite useful papers.
There 2 papers that cite this one may also be interesting.

A* variants

Sun, 12 Jun 2022 12:04:00 +0200

These are some quick notes listing papers related to A* itself and variants. In particular, here I’m interested in papers that update $h$ during the A* search, as a background for pruning.

Specifically, our version of pruning increases $h$ during a single A* search, and in fact the heuristic becomes in-admissible after pruning.

Changing $h$ Link to heading

The original A* paper has a proof of optimality. Later papers consider this also with heuristics that change their value over time.

A survey of exact global pairwise alignment

Fri, 01 Apr 2022 00:00:00 +0200

This post explains the many variants of pairwise alignment, and covers papers defining and exploring the topic.

Spaced k-mer and assembler methods

Wed, 14 Jul 2021 00:00:00 +0200

Table of Contents

Spaced $k$-mers
Minimap
SPAdes
MUMmer4
BLASR
Bowtie 2
Patternhunter
Spaced seeds improve $k$-mer-based metagenomic classification
LoMeX
Meeting notes

Concepts:

Mapping Map a sequence onto a reference genome/dataset
Assembly Build a genome from a set of reads
- de novo (implied): without using a reference genome
- Otherwise just called mapping

Typical complicating factors:

read errors
non-uniform coverage
insert size variation
chimeric reads (?)
bireads
non-uniform read coverage (as in metagenomics, i.e. multi cell assembly)

Spaced $k$-mers Link to heading

Also called

Survey on CuriousCoding

Range Minimum Queries

Wheeler graphs

1 Deterministic Finite Automaton (DFA) Link to heading

Recent results on hash tables

Overview of static data structures

A History of Pairwise Alignment

Low Density Minimizers

SimdSketch: a fast bucket sketch

Types of tigs

1 De Bruijn graph Link to heading

2 k-mers Link to heading

Minimizer papers

FM-index implementations

A note on SDSL versions Link to heading

PACE 24

Tools for suffix array searching

1 Sapling Link to heading

Crates for suffix array construction

References Link to heading

Mod-minimizers and other minimizers

Shortest paths, bucket queues, and A* on the edit graph

The complexity and performance of WFA and band doubling

Bidirectional A*

A* variants

Changing \(h\) Link to heading

A survey of exact global pairwise alignment

Spaced k-mer and assembler methods

Spaced \(k\)-mers Link to heading