Algorithms
Search and filter the Atlas by algorithm behavior, governance metadata, and readiness.
Showing 1004 of 1004 algorithms
Bubble Sort
Sorts a list by repeatedly swapping neighboring items that are out of order.
Insertion Sort
Sorts a list by inserting each item into the correct position within the already-sorted prefix.
Selection Sort
Sorts by repeatedly selecting the smallest remaining item.
Merge Sort
Sorts a list by recursively sorting halves and merging the sorted results.
Quick Sort
Sorts a list by partitioning values around a pivot and recursively sorting each side.
Heap Sort
Sorts a list by building a heap and repeatedly removing the highest-priority item.
Counting Sort
Sorts integer values by counting how many times each value appears.
Radix Sort
Sorts values by processing one digit or character position at a time.
Bucket Sort
Sorts by distributing values into buckets and sorting within each bucket.
Shell Sort
Sorts by comparing items far apart, then gradually reducing the gap.
Tim Sort
Sorts by detecting existing ordered runs and merging them with safeguards for real-world data.
Linear Search
Finds a target by checking items one by one until a match is found or the input ends.
Binary Search
Finds a target or insertion point in sorted data by repeatedly halving the candidate range.
Interpolation Search
Searches sorted numeric data by estimating where the target should be.
Binary Search on Answer
Finds an optimal numeric answer by binary searching a monotone feasibility predicate.
Exponential Search
Finds a search range by doubling the bound, then uses binary search inside it.
Fibonacci Search
Searches sorted data using Fibonacci-sized partitions.
Hash Lookup
Finds values by hashing keys directly to likely storage locations.
Jump Search
Searches sorted data by jumping ahead in blocks before scanning a small block.
Quickselect
Finds the kth smallest item by partitioning around pivots without fully sorting.
Ternary Search
Finds an optimum in a unimodal range by comparing two interior points.
Breadth-First Search
Explores a graph from a start node in increasing number of edges.
Depth-First Search
Explores a graph by following one path as far as possible before backtracking.
Topological Sort
Orders the nodes of a directed acyclic graph so every prerequisite appears before its dependents.
Articulation Point Detection
Finds graph nodes whose removal would split a connected graph.
Bidirectional Search
Searches from both the start and goal until the frontiers meet.
Connected Components
Groups graph nodes by which nodes can reach each other.
Cycle Detection
Determines whether a graph contains a cycle.
Iterative Deepening DFS
Runs depth-first search repeatedly with increasing depth limits.
Kosaraju's Algorithm
Finds strongly connected components using two passes of depth-first search.
Tarjan's Strongly Connected Components
Finds strongly connected components in one depth-first search pass.
Dijkstra's Algorithm
Finds shortest paths from one source in a graph with nonnegative edge weights.
A* Search
Finds a low-cost path by combining path cost so far with a heuristic estimate to the goal.
Bellman-Ford
Finds single-source shortest paths even when edges can have negative weights.
Floyd-Warshall
Finds shortest paths between every pair of nodes.
Greedy Best-First Search
Expands the node that appears closest to the goal by heuristic estimate.
Hierarchical Pathfinding
Speeds pathfinding by planning through coarse regions before refining locally.
Johnson's Algorithm
Finds all-pairs shortest paths in sparse graphs by reweighting edges.
Jump Point Search
Speeds up grid pathfinding by skipping over symmetric intermediate nodes.
Lee Algorithm
Finds shortest paths on a grid by expanding wavefront distances.
Yen's K Shortest Paths
Finds several shortest loopless paths between the same two nodes.
Run-Length Encoding
Compresses repeated consecutive values by storing each value with its run length.
Huffman Coding
Builds a prefix code that gives shorter bit strings to more frequent symbols.
LZ77
Compresses repeated substrings by referring back to earlier bytes in a sliding window.
LZW
Compresses streams by replacing repeated phrases with dictionary codes built during encoding.
Arithmetic Coding
Encodes a message as a number inside a probability interval.
Brotli
Compresses web content with dictionary references and entropy coding.
Burrows-Wheeler Transform
Reorders text so similar characters become easier to compress.
Deflate
Compresses data by combining LZ77 backreferences with Huffman-coded symbols.
Delta Encoding
Stores changes between neighboring values instead of the values themselves.
Golomb Coding
Encodes small nonnegative integers compactly when small values are common.
Prediction by Partial Matching
Compresses by predicting the next symbol from recent context.
RSA
Uses modular arithmetic with a public key and private key for encryption or signatures.
Diffie-Hellman Key Exchange
Lets two parties derive a shared secret over an insecure channel.
AES
Encrypts fixed-size blocks with a symmetric key using repeated substitution and permutation rounds.
SHA-256
Computes a fixed 256-bit cryptographic hash of an input message.
Argon2
Hashes passwords with tunable memory and time cost.
ChaCha20
Encrypts data with a fast stream cipher built from add-rotate-xor rounds.
EdDSA
Creates deterministic elliptic-curve signatures on Edwards curves.
Elliptic Curve Diffie-Hellman
Establishes a shared secret using elliptic-curve key exchange.
Elliptic Curve Digital Signature Algorithm
Creates digital signatures with elliptic-curve keys.
HMAC
Authenticates messages by combining a hash function with a shared secret key.
Gradient Descent
Minimizes an objective by repeatedly moving parameters opposite the gradient.
Newton's Method
Finds a root or optimum by repeatedly using local derivative information to form a better approximation.
Simulated Annealing
Searches for good solutions while sometimes accepting worse moves early on.
Genetic Algorithm
Evolves a population of candidate solutions through selection and variation.
Adam Optimizer
Adapts gradient updates using moving averages of gradients and squared gradients.
Branch and Bound
Searches solution branches while pruning branches that cannot improve the best result.
Coordinate Descent
Optimizes one parameter or coordinate at a time.
Linear Programming Simplex Method
Optimizes a linear objective by moving between vertices of a feasible region.
Nelder-Mead
Optimizes without derivatives by moving a simplex through the search space.
Stochastic Gradient Descent
Updates parameters using gradients from one example or a small batch at a time.
Linear Regression
Fits a linear model that predicts a numeric target from input features.
Logistic Regression
Models class probability by applying a logistic function to a linear score.
K-Means
Clusters points by alternating between assigning points to nearest centroids and updating those centroids.
Decision Tree
Predicts by recursively splitting examples with feature tests into simpler subgroups.
Random Forest
Builds an ensemble of decision trees trained on random samples and feature subsets.
Backpropagation
Computes neural-network gradients by applying the chain rule backward through layers.
DBSCAN
Clusters points by dense neighborhoods and labels sparse points as noise.
K-Nearest Neighbors
Predicts from the labels or values of the closest training examples.
Naive Bayes
Classifies examples using feature probabilities and a simplifying independence assumption.
Principal Component Analysis
Projects data onto orthogonal directions that capture the largest variance.
Support Vector Machine
Learns a separating decision boundary by maximizing the margin around support vectors.
Rasterization
Converts geometric shapes into pixels on a screen.
Ray Tracing
Renders images by tracing rays from the camera into a scene.
Path Tracing
Simulates light transport by sampling random paths through a scene.
Z-Buffering
Keeps the closest visible fragment for each pixel.
Ambient Occlusion
Darkens areas where nearby geometry blocks ambient light.
Marching Cubes
Extracts a triangle surface from a 3D scalar field.
Photon Mapping
Simulates global illumination by tracing photons from light sources.
Ray Marching
Renders by stepping along rays until they hit or pass through scene features.
Scanline Rendering
Renders polygons row by row across the image.
Screen Space Ambient Occlusion
Approximates ambient occlusion from the visible depth buffer.
Shadow Mapping
Creates shadows by comparing camera pixels with depth from the light's view.
Sphere Tracing
Ray marches signed distance fields using safe distance steps.
Euler Integration
Approximates motion by stepping forward using the current rate of change.
Verlet Integration
Updates motion using current and previous positions.
Runge-Kutta Method
Approximates differential equations by sampling several slopes per step.
Monte Carlo Simulation
Estimates outcomes by running many random trials.
Cellular Automata
Updates grid cells from simple local rules.
Finite Difference Method
Approximates differential equations with differences on a grid.
N-Body Simulation
Simulates many bodies interacting through forces such as gravity.
Position Based Dynamics
Simulates motion by directly adjusting positions to satisfy constraints.
Semi-Implicit Euler
Updates velocity before position for a more stable Euler-style physics step.
Smoothed Particle Hydrodynamics
Simulates fluids with particles that estimate local density and pressure.
Bisection Method
Finds a root by repeatedly halving an interval that contains it.
Gaussian Elimination
Solves linear systems by eliminating variables row by row.
LU Decomposition
Factors a matrix into lower and upper triangular matrices.
Fast Fourier Transform
Computes the discrete Fourier transform efficiently by reusing symmetry and subproblem structure.
Conjugate Gradient
Solves large symmetric positive-definite linear systems with iterative search directions.
Fixed Point Iteration
Solves equations by repeatedly applying a function until the value stops changing.
Gauss-Seidel Method
Solves linear systems by updating variables immediately as new values are available.
Jacobi Method
Solves linear systems by repeatedly updating each variable from the previous iteration.
Secant Method
Finds roots using a line through two recent estimates.
Simpson's Rule
Approximates an integral by fitting parabolas over intervals.
Convolution
Combines two signals or arrays by sliding one over the other and summing pointwise products.
Discrete Fourier Transform
Represents a finite sequence as weighted sums of discrete complex sinusoids.
Kalman Filter
Estimates hidden state by blending predictions with noisy measurements.
Moving Average
Smooths a sequence by replacing each value with an average over a nearby window.
Autocorrelation
Measures how similar a signal is to shifted versions of itself.
High-Pass Filter
Attenuates low-frequency signal components while preserving rapid changes.
Inverse Fast Fourier Transform
Reconstructs time-domain samples from frequency-domain coefficients efficiently.
Low-Pass Filter
Attenuates high-frequency signal components while preserving slower variations.
Median Filter
Replaces each sample or pixel with the median of a local neighborhood.
Short-Time Fourier Transform
Analyzes frequency content over short moving windows of time.
Windowing
Shapes a signal segment before frequency analysis to reduce edge artifacts.
Convex Hull
Finds the smallest convex boundary that contains a set of points.
Graham Scan
Computes a convex hull by sorting points by angle and keeping valid turns.
Line Segment Intersection
Determines whether two line segments cross or touch.
Point in Polygon
Tests whether a point lies inside a polygon.
Delaunay Triangulation
Triangulates points so triangles avoid skinny angles as much as possible.
Jarvis March
Finds a convex hull by wrapping around the outside point by point.
Quickhull
Finds a convex hull by recursively choosing farthest outside points.
Separating Axis Theorem
Tests convex shape overlap by looking for an axis that separates them.
Sweep Line Algorithm
Processes geometric events in sorted order as a line moves across the plane.
Voronoi Diagram
Partitions space into regions closest to each input site.
Round Robin Scheduling
Gives each ready task a fixed time slice in cyclic order.
Earliest Deadline First
Runs the ready task with the nearest deadline first.
Shortest Job First
Runs the ready task with the smallest expected processing time.
Critical Path Method
Finds the longest dependency path that determines a project's minimum completion time.
First Come First Served Scheduling
Runs tasks in the order they arrive.
Least Laxity First
Runs the task with the least spare time before its deadline.
Multilevel Feedback Queue
Uses several priority queues and moves tasks based on their behavior.
Priority Scheduling
Runs the ready task with the highest priority.
Rate Monotonic Scheduling
Assigns higher priority to periodic tasks with shorter periods.
Work Stealing
Balances parallel work by letting idle workers take tasks from busy workers.
Naive String Search
Finds a pattern by checking every possible starting position.
Knuth-Morris-Pratt
Finds pattern matches in text by using a prefix table to skip redundant comparisons.
Boyer-Moore
Searches text by comparing from the end of the pattern and making large skips.
Rabin-Karp
Searches for a pattern by comparing rolling hash values.
Aho-Corasick
Finds many patterns in one text scan using an automaton.
Levenshtein Distance
Measures how many insertions, deletions, or substitutions transform one string into another.
Needleman-Wunsch
Globally aligns two sequences with dynamic programming.
Regular Expression Matching
Matches text against patterns with operators such as choice, repetition, and character classes.
Suffix Array Search
Finds substrings by binary searching a sorted array of suffixes.
Z Algorithm
Computes how much each string suffix matches the string prefix.
Hash Table
Stores key-value pairs in buckets chosen by a hash function for fast average-case lookup.
Binary Search Tree
Stores ordered keys in a tree where left descendants are smaller and right descendants are larger.
Heap
Maintains a partial order so the minimum or maximum item can be found quickly.
Trie
Stores strings by sharing prefixes along paths through a tree.
B-Tree
Stores sorted keys in wide balanced nodes for efficient disk or page access.
Bloom Filter
Tests set membership with a compact bit array that allows false positives but not false negatives.
Fenwick Tree
Maintains prefix aggregates in an array using index ranges encoded by low bits.
Red-Black Tree
Maintains a balanced binary search tree with color rules.
Segment Tree
Maintains aggregate values over intervals by storing summaries in a binary tree.
Union-Find
Maintains disjoint sets with near-constant-time find and union operations.
Sobel Edge Detection
Finds edges by measuring horizontal and vertical brightness changes.
Gaussian Blur
Smooths an image by convolving it with a Gaussian kernel.
Thresholding
Separates pixels into groups based on whether they cross a chosen value.
Flood Fill
Fills a connected region starting from one seed point.
Bilateral Filter
Smooths images while preserving edges by considering distance and color similarity.
Canny Edge Detection
Finds thin edges by smoothing, measuring gradients, suppressing nonmaxima, and linking thresholds.
Histogram Equalization
Improves contrast by spreading image intensities across the available range.
Hough Transform
Detects shapes by voting in a parameter space.
Laplacian Edge Detection
Finds edges by measuring second-order brightness changes.
Morphological Erosion
Shrinks bright or foreground regions using a local structuring element.
Fisher-Yates Shuffle
Randomly shuffles a list so every ordering is equally likely.
Reservoir Sampling
Selects a fixed-size random sample from a stream of unknown length.
Rejection Sampling
Samples from a target distribution by rejecting some easier samples.
Importance Sampling
Estimates quantities by sampling more often from important regions.
Box-Muller Transform
Generates normally distributed random values from uniform random values.
Linear Congruential Generator
Generates pseudorandom numbers with a simple linear recurrence.
Mersenne Twister
Generates pseudorandom numbers with a very long period.
Metropolis-Hastings
Samples from a target distribution by accepting or rejecting proposed moves.
Poisson Disk Sampling
Places random points while keeping a minimum distance between them.
Stratified Sampling
Samples separately from groups so each group is represented.
Recursive Descent Parsing
Parses input with one function per grammar rule.
Pratt Parsing
Parses expressions by assigning binding powers to tokens and recursing by precedence.
CYK Algorithm
Checks whether a string can be generated by a context-free grammar.
Dijkstra's Two-Stack Algorithm
Evaluates fully parenthesized expressions with separate stacks for operators and values.
Earley Parser
Parses general context-free grammars with a chart of partial parse states.
LL Parsing
Parses input from left to right using leftmost derivations.
LR Parsing
Parses input bottom-up with shift and reduce actions.
Operator Precedence Parsing
Parses expressions by comparing precedence relations between operators.
Packrat Parsing
Parses with memoized recursive descent for linear-time parsing expression grammars.
Shunting Yard Algorithm
Converts infix expressions to postfix form using operator and output stacks.
Perlin Noise
Generates smooth random-looking variation over space.
Simplex Noise
Generates coherent noise using simplex-shaped grid cells.
Wave Function Collapse
Generates layouts by repeatedly choosing low-uncertainty cells and propagating constraints.
Binary Space Partitioning Dungeon Generation
Builds dungeon rooms by recursively splitting space into partitions.
Cellular Automata Cave Generation
Creates cave-like maps by smoothing random grids with neighbor rules.
Diamond-Square Algorithm
Generates fractal height maps by alternating square and diamond averaging steps.
Domain Warping
Distorts sampling coordinates with another noise field before evaluating procedural patterns.
Drunkard's Walk
Generates paths or caves by moving a random walker through a grid.
Fractal Brownian Motion
Layers noise at multiple frequencies to create richer natural variation.
L-System
Generates structures by repeatedly rewriting symbols with grammar rules.
External Sort
Sorts data sets that are too large to fit in memory by sorting chunks and merging them from disk.
Lower Bound
Finds the first sorted position where a value could be inserted without breaking order.
Median of Medians
Selects a pivot that guarantees linear-time selection in the worst case.
Minimum Spanning Tree
Connects all nodes in a weighted graph with the lowest total edge cost and no cycles.
Kruskal's Algorithm
Builds a minimum spanning tree by adding the cheapest edges that do not create cycles.
Prim's Algorithm
Builds a minimum spanning tree by repeatedly attaching the cheapest edge from the tree to a new node.
Dynamic Programming on DAGs
Solves graph problems by processing directed acyclic graph nodes in dependency order.
Acyclic Shortest Path
Finds shortest paths in a weighted DAG by relaxing edges in topological order.
Flow Field Pathfinding
Guides many agents toward a goal by precomputing a direction field over a grid.
Theta*
Finds smoother grid paths by allowing line-of-sight shortcuts during A* search.
D* Lite
Repairs shortest paths efficiently when edge costs change during navigation.
ANS Coding
Encodes symbols near entropy limits using a single integer state machine.
Range Coding
Compresses symbols by narrowing a numeric range according to their probabilities.
Bit-Packing
Stores small integer values using only the number of bits they need.
BLAKE3
Computes a fast cryptographic hash using a tree structure that can run in parallel.
HKDF
Derives strong key material from shared secrets using HMAC-based extract and expand steps.
Shamir's Secret Sharing
Splits a secret into shares so only a threshold number of shares can reconstruct it.
BFGS
Optimizes smooth functions by updating an approximation of second-order curvature.
L-BFGS
Runs BFGS-style optimization while storing only a limited history of curvature updates.
Levenberg-Marquardt
Solves nonlinear least-squares problems by blending Gauss-Newton steps with damping.
Interior Point Method
Solves constrained optimization problems by moving through the interior of the feasible region.
Gradient Clipping
Limits gradient size so optimization updates do not become unstable.
Proximal Gradient Method
Optimizes objectives with a smooth part and a nonsmooth regularization term.
Hill Climbing
Improves a solution by repeatedly moving to a better neighboring solution.
Beam Search
Keeps only the best few partial solutions while exploring a large search space.
Ridge Regression
Fits linear regression with an L2 penalty that shrinks coefficients.
Lasso Regression
Fits a linear model while encouraging some weights to become exactly zero.
Elastic Net
Combines L1 and L2 penalties for sparse but more stable linear models.
Gaussian Mixture Model
Models data as a weighted blend of several Gaussian distributions.
t-SNE
Embeds high-dimensional points into two or three dimensions while preserving local neighborhoods.
Perceptron
Learns a linear binary classifier by updating weights after mistakes.
Multilayer Perceptron
Uses stacked fully connected layers and nonlinear activations to learn flexible functions.
Transformer Attention
Lets each token combine information from other tokens using learned query, key, and value vectors.
Q-Learning
Learns action values from rewards without needing a model of the environment.
Whitted Ray Tracing
Traces primary, reflection, and refraction rays for sharp recursive lighting effects.
Deferred Shading
Separates geometry rendering from lighting by first storing surface data in screen-space buffers.
Forward Rendering
Shades objects as they are drawn directly into the final image.
Tiled Rendering
Divides the screen into tiles so each tile can process only nearby or relevant lights.
Clustered Shading
Groups screen space and depth into clusters so lights are culled in three dimensions.
Screen Space Reflections
Approximates reflections by ray marching through already rendered screen-space depth.
Temporal Anti-Aliasing
Reduces aliasing by accumulating jittered samples across frames.
FXAA
Smooths jagged image edges with a fast post-process filter.
Next Event Estimation
Reduces path tracing noise by sampling direct light sources at each shading point.
Rigid Body Dynamics
Simulates objects that translate and rotate while keeping their shape fixed.
Mass-Spring System
Simulates connected particles using spring forces between neighboring masses.
Cloth Simulation
Simulates fabric-like motion with connected particles, constraints, or continuum models.
Position Based Fluids
Simulates fluids by adjusting particle positions to satisfy density constraints.
Navier-Stokes Projection
Makes a fluid velocity field incompressible by subtracting pressure gradients.
Semi-Lagrangian Advection
Moves quantities through a velocity field by tracing backward from grid cells.
Vorticity Confinement
Adds small swirling forces back into fluid simulations to counter numerical damping.
Implicit Integration
Advances simulation state using equations evaluated at the future state for better stability.
Cholesky Decomposition
Factors a symmetric positive definite matrix into a triangular matrix and its transpose.
Eigenvalue Decomposition
Represents a matrix through directions that are only scaled by the matrix.
Broyden's Method
Solves nonlinear systems by updating an approximate Jacobian instead of recomputing it.
Romberg Integration
Improves trapezoidal integration estimates with extrapolation.
Monte Carlo Integration
Approximates integrals by averaging random samples.
Adaptive Quadrature
Numerically integrates by subdividing intervals where the error estimate is too high.
Multigrid Method
Solves grid-based systems faster by correcting error across coarse and fine grids.
Butterworth Filter
Filters signals with a smooth passband and monotonic frequency response.
Savitzky-Golay Filter
Smooths data by fitting a low-degree polynomial inside a moving window.
Exponential Moving Average
Smooths a sequence by blending each new value with the previous smoothed value.
Goertzel Algorithm
Efficiently measures one selected frequency bin from a signal.
Phase Vocoder
Changes time scale or pitch by manipulating short-time Fourier transform frames.
Overlap-Add
Reconstructs or filters long signals by summing overlapping processed blocks.
FIR Filter
Filters a signal using a finite weighted sum of current and previous input samples.
Sutherland-Hodgman Polygon Clipping
Clips a polygon against each boundary of a convex clipping region.
Bentley-Ottmann Algorithm
Finds all line segment intersections with a sweep line and event queue.
Rotating Calipers
Solves convex polygon measurements by rotating supporting lines around the hull.
Fortune's Algorithm
Constructs a Voronoi diagram with a sweep line and beach line.
Bowyer-Watson Algorithm
Builds a Delaunay triangulation by inserting points and retriangulating invalid cavities.
Closest Pair of Points
Finds the two points with the smallest distance between them.
Ray-Triangle Intersection
Finds whether and where a ray hits a triangle.
Signed Distance Function Evaluation
Computes distance to a shape boundary with sign indicating inside or outside.
Fair Queuing
Schedules work so competing flows receive a fair share of service.
Weighted Round Robin
Cycles through queues while giving higher-weight queues more service opportunities.
Dynamic Time Warping
Measures similarity between sequences that may be stretched or shifted in time.
Longest Common Subsequence
Finds the longest sequence that appears in two inputs without requiring contiguous positions.
Hamming Distance
Counts positions where two equal-length strings or vectors differ.
Quadtree
Indexes 2D space by recursively subdividing regions into four quadrants.
Octree
Indexes 3D space by recursively subdividing regions into eight octants.
k-d Tree
Indexes points by recursively splitting space along coordinate axes.
R-Tree
Indexes rectangles or spatial objects with nested bounding boxes.
Spatial Hash
Maps spatial positions into grid cells stored in a hash table.
Sparse Table
Precomputes overlapping power-of-two ranges for fast static range queries.
Rope
Stores long strings as a tree of smaller chunks for efficient edits and concatenation.
Circular Buffer
Stores a fixed-size queue by wrapping read and write positions around an array.
Difference of Gaussians
Highlights image structures by subtracting two Gaussian-blurred versions at different scales.
Connected Component Labeling
Assigns labels to contiguous foreground regions in a binary or segmented image.
Sobol Sequence
Generates low-discrepancy samples that cover a multidimensional space evenly.
Alias Method
Samples from a discrete weighted distribution in constant time after preprocessing.
PEG Parsing
Parses text using ordered-choice grammar rules that describe one intended parse.
Tokenization
Breaks raw text into meaningful tokens before parsing or analysis.
Worley Noise
Generates cellular patterns from distances to nearby feature points.
Value Noise
Creates smooth noise by interpolating random values stored on a grid.
Ridged Multifractal Noise
Builds sharp ridge-like terrain by inverting and layering noise octaves.
Hydraulic Erosion
Shapes terrain by simulating water carrying and depositing sediment.
Thermal Erosion
Smooths steep terrain by moving material from unstable slopes to lower neighbors.
Space Colonization Algorithm
Generates branching structures by growing toward nearby attraction points.
Reaction-Diffusion
Creates organic patterns by simulating chemicals that spread and react on a grid.
Parallel Merge Sort
Sorts large collections by splitting merge sort work across workers and merging sorted partitions.
Kahn's Algorithm
Produces a topological ordering by repeatedly removing nodes with no incoming edges.
Bridge Detection
Finds edges whose removal would disconnect an undirected graph.
Hierholzer's Algorithm
Builds an Eulerian path or circuit by splicing cycles that consume every edge once.
Euler Tour
Records entry and exit order while traversing a tree or graph.
Tarjan's Offline LCA
Answers lowest-common-ancestor queries in a tree using DFS and union-find.
Binary Lifting LCA
Answers tree ancestor queries by precomputing powers-of-two jumps.
Ford-Fulkerson
Computes maximum flow by repeatedly augmenting along residual paths.
Edmonds-Karp
Computes maximum flow by choosing shortest augmenting paths with BFS.
Dinic's Algorithm
Computes maximum flow using level graphs and blocking flows.
Hopcroft-Karp
Finds maximum bipartite matching by augmenting many shortest paths per phase.
Bidirectional Dijkstra
Finds a shortest path by running Dijkstra search forward from the start and backward from the goal.
Fringe Search
Searches with A*-style costs while batching nodes by a moving cost threshold.
IDA*
Combines A* scoring with iterative deepening to search with lower memory use.
Lifelong Planning A*
Reuses previous A* search work when graph costs change.
D* Search
Repairs paths for a moving agent as new obstacle or cost information appears.
Contraction Hierarchies
Speeds shortest-path queries by contracting less important nodes and adding shortcut edges.
ALT Landmarks
Uses landmark distances and triangle inequalities to guide shortest-path search.
Multi-Source Dijkstra
Finds shortest distances from the nearest of several source nodes in a nonnegative-weight graph.
Anytime Repairing A*
Quickly finds a usable path and improves it as more time is available.
Rapidly-Exploring Random Tree
Builds a tree of random feasible motions that quickly explores open space.
Variable-Length Encoding
Represents common values with shorter codes and uncommon values with longer codes.
Elias Gamma Coding
Encodes positive integers with a unary length prefix and binary payload.
Elias Delta Coding
Encodes positive integers by gamma-coding the binary length before the payload.
Rice Coding
Encodes nonnegative integers using quotient-remainder codes with a power-of-two divisor.
Move-to-Front Transform
Replaces each symbol with its position in a changing list moved to the front after use.
Byte Pair Encoding
Repeatedly replaces frequent adjacent symbol pairs with new symbols.
Zstandard Compression
Combines LZ-style matching with modern entropy coding for fast general-purpose compression.
LZMA
Compresses data with LZ-style matches and range-coded probability models.
PBKDF2
Derives keys from passwords by iterating a pseudorandom function with a salt.
Scrypt
Derives password keys with intentionally high memory use to resist hardware guessing.
SipHash
Computes a fast keyed hash for short messages and hash-table protection.
Feistel Network
Builds an invertible block cipher structure from repeated round functions.
Merkle-Damgard Construction
Builds a hash function by chaining a compression function over message blocks.
One-Time Pad
Encrypts a message by combining it with a truly random key used exactly once.
Zero-Knowledge Proof
Lets one party prove a statement without revealing the secret that makes it true.
Merkle Tree
Builds a tree of hashes so large datasets can be checked with small proofs.
Particle Swarm Optimization
Searches for good solutions by moving particles according to personal and group best positions.
Ant Colony Optimization
Solves combinatorial problems by reinforcing paths that produce good solutions.
Tabu Search
Improves solutions with local moves while forbidding recently visited moves or states.
Differential Evolution
Optimizes continuous parameters by combining differences between population members.
CMA-ES
Optimizes continuous functions by adapting a Gaussian search distribution.
Bayesian Optimization
Optimizes expensive black-box functions using a surrogate model and acquisition rule.
Golden Section Search
Finds the minimum of a unimodal one-dimensional function by shrinking an interval efficiently.
Powell's Method
Minimizes a function by performing line searches along evolving directions.
ADMM
Solves constrained optimization problems by alternating primal updates and dual correction.
Expectation-Maximization
Fits latent-variable models by alternating expected assignments and parameter updates.
RANSAC
Fits a model by repeatedly sampling small subsets and keeping the model with the most inliers.
Constraint Satisfaction Backtracking
Solves constraint problems by assigning variables recursively and undoing inconsistent choices.
Softmax Classifier
Classifies examples by turning linear class scores into probabilities.
Cross-Entropy Loss
Measures how well predicted probabilities match the true class distribution.
Convolutional Neural Network
Learns local filters that detect patterns across grid-like data such as images.
Recurrent Neural Network
Processes sequences by carrying hidden state from one step to the next.
Long Short-Term Memory
Uses gates and a memory cell to model longer sequence dependencies.
GRU
Models sequences with gated hidden-state updates using fewer gates than LSTM.
Autoencoder
Learns a compact representation by reconstructing its input.
Variational Autoencoder
Learns a probabilistic latent space that can reconstruct and generate examples.
Gradient Boosting
Builds an ensemble by adding weak models that reduce current prediction error.
AdaBoost
Builds a classifier by reweighting examples that previous weak learners misclassified.
XGBoost-Style Gradient Boosted Trees
Trains regularized boosted decision trees using gradient and curvature information.
Apriori Algorithm
Finds frequent itemsets by expanding only candidates whose subsets are frequent.
Hidden Markov Model
Models sequences with hidden states that emit observed values over time.
UMAP
Embeds high-dimensional data into a lower-dimensional layout that preserves local neighborhoods.
Parser Combinators
Builds parsers by composing small parser functions into larger grammar rules.
DFA Construction
Builds a deterministic finite automaton by grouping NFA state sets into DFA states.
NFA Simulation
Matches input by tracking all possible nondeterministic automaton states.
Thompson's Construction
Compiles a regular expression into an epsilon-NFA using small pattern fragments.
GLR Parsing
Parses ambiguous or nondeterministic grammars by following multiple LR parse paths.
LALR Parsing
Builds compact LR-style parse tables by merging states with the same cores.
FIRST/FOLLOW Set Computation
Computes grammar symbol sets used to predict valid parser choices.
LL(1) Parse Table Construction
Builds a predictive parsing table from FIRST and FOLLOW sets.
Gradient Noise
Generates smooth noise by interpolating dot products with random lattice gradients.
Midpoint Displacement
Generates rough terrain or curves by recursively displacing midpoints.
Voronoi Terrain Generation
Builds terrain regions from distances to seed points or Voronoi cells.
Markov Chain Text Generation
Generates text by choosing each token from probabilities conditioned on recent tokens.
Grammar-Based Generation
Generates structures by expanding grammar symbols into rules.
Constraint-Based Generation
Generates content by searching for assignments that satisfy design constraints.
Poisson Disk Object Placement
Places objects with a minimum spacing so distributions look natural but not clumped.
Fault Formation Terrain
Creates terrain by repeatedly raising one side of random fault lines.
Tectonic Plate Terrain Generation
Generates large terrain features from simulated plate regions and interactions.
Diffusion-Limited Aggregation
Generates branching clusters by letting random walkers stick to an existing structure.
Shape Grammar Generation
Generates geometry by repeatedly applying spatial rewrite rules to shapes.
Wave Function Collapse Overlapping Model
Generates grids by enforcing local pattern compatibility learned from overlapping examples.
Unsharp Masking
Sharpens an image by adding back high-frequency detail separated by blur.
Template Matching
Finds image regions that resemble a smaller template patch.
GrabCut
Segments foreground from background using graph cuts and color models.
Lucas-Kanade Optical Flow
Estimates local image motion by solving small least-squares systems over patches.
Horn-Schunck Optical Flow
Estimates dense optical flow by combining brightness constancy with smoothness.
Image Pyramid
Stores progressively downsampled versions of an image for multi-scale processing.
Integral Image
Precomputes cumulative pixel sums so rectangular sums are answered in constant time.
Morphological Dilation
Expands bright or foreground regions according to a structuring element.
Watershed Segmentation
Segments regions by treating image intensity as a terrain flooded from markers.
Halton Sequence
Generates deterministic low-discrepancy points from radical inverses in prime bases.
Hammersley Sequence
Generates low-discrepancy points using an index coordinate and radical inverse coordinates.
Latin Hypercube Sampling
Samples each dimension so every interval stratum is used exactly once.
Gibbs Sampling
Samples a joint distribution by repeatedly sampling each variable from its conditional distribution.
Inverse Transform Sampling
Samples a target distribution by applying its inverse CDF to uniform random values.
Multinomial Sampling
Draws counts or categories according to a discrete probability vector.
Cranley-Patterson Rotation
Randomizes low-discrepancy samples by adding a random offset modulo one.
Lottery Scheduling
Allocates CPU time by randomly drawing tickets assigned to competing jobs.
Earliest Start Time
Computes the earliest time each task can begin after its prerequisites finish.
Latest Finish Time
Computes how late each task can finish without delaying the project.
Job Shop Scheduling
Schedules jobs across machines while respecting operation order and machine capacity.
Longest Common Substring
Finds the longest contiguous block shared by two strings.
Smith-Waterman
Finds the best local alignment between two sequences.
Jaro-Winkler Distance
Scores string similarity with extra weight for shared prefixes.
MinHash
Estimates set similarity by comparing compact hash signatures.
Locality-Sensitive Hashing
Hashes similar items into the same buckets with higher probability than dissimilar items.
Suffix Automaton
Represents all substrings of a string in a compact deterministic automaton.
Bitap Algorithm
Searches for patterns by updating bit masks that represent matching prefixes.
Wu-Manber
Searches for multiple patterns using block hashes and shift tables.
Deque
Stores items so insertion and removal are efficient at both the front and the back.
Priority Queue
Stores items so the highest- or lowest-priority item can be removed efficiently.
Graph Adjacency List
Represents a graph by storing each node with the neighbors reachable from it.
Graph Adjacency Matrix
Represents graph edges with a matrix indexed by source and destination nodes.
Directed Acyclic Graph
Represents directed dependencies with no cycle following edge directions.
AVL Tree
Maintains a binary search tree with strict height balance after updates.
Splay Tree
Moves recently accessed nodes to the root using rotations.
Treap
Combines binary search tree ordering with random heap priorities.
Skip List
Maintains sorted items with multiple randomized forward-pointer levels.
LRU Cache
Evicts the least recently used item when capacity is exceeded.
Persistent Segment Tree
Keeps previous segment tree versions by copying only nodes along update paths.
Wavelet Tree
Indexes sequences so rank, select, and range queries can be answered compactly.
Suffix Tree
Stores all suffixes of a string in a compressed trie for fast substring queries.
Suffix Array
Stores suffix starting positions in lexicographic order for compact string indexing.
Chebyshev Filter
Designs a frequency filter with controlled ripple and a sharper transition band.
IIR Filter
Filters a signal with feedback from previous outputs as well as current and previous inputs.
Wavelet Transform
Represents a signal at multiple scales using localized wavelet functions.
Continuous Wavelet Transform
Analyzes a signal across continuously varying scales and shifts.
Hilbert Transform
Builds an analytic signal by phase-shifting frequency components.
Cepstrum Analysis
Analyzes periodic structure by transforming the log spectrum back into a quefrency-like domain.
Spectral Subtraction
Reduces noise by subtracting an estimated noise spectrum from the observed spectrum.
Overlap-Save
Performs long convolution by reusing overlapped input blocks and discarding invalid edges.
Polyphase Resampling
Resamples a signal efficiently by splitting interpolation filters into phases.
Windowed Sinc Interpolation
Interpolates samples with a sinc kernel limited by a window function.
LMS Adaptive Filter
Adapts filter weights to minimize the current squared error.
Notch Filter
Suppresses a narrow frequency band while leaving nearby frequencies mostly intact.
Band-Pass Filter
Passes frequencies inside a chosen band while attenuating lower and higher frequencies.
Matched Filter
Detects a known signal pattern by correlating input with a matching template.
Weiler-Atherton Polygon Clipping
Clips complex polygons by walking between subject and clipping polygon boundaries at intersections.
Minimum Bounding Rectangle
Finds the smallest-area rectangle that encloses a set of points or a convex polygon.
Point-Line Distance
Computes the shortest distance from a point to a line.
Axis-Aligned Bounding Box Intersection
Tests whether two axis-aligned boxes overlap on every coordinate axis.
Oriented Bounding Box Intersection
Tests overlap between rotated boxes using candidate separating axes.
Bounding Volume Hierarchy Construction
Builds a tree of bounding volumes around geometry for faster spatial queries.
Minkowski Sum
Combines two shapes by adding every point in one shape to every point in the other.
Ramer-Douglas-Peucker
Simplifies a polyline by removing points whose deviation is below a tolerance.
Marching Squares
Extracts 2D contour lines from a scalar grid using cell case tables.
Ear Clipping Triangulation
Triangulates a simple polygon by repeatedly removing valid ears.
Barycentric Coordinates
Represents a point inside a triangle as weights on the triangle's vertices.
Laplacian Mesh Smoothing
Smooths a mesh by moving vertices toward the average of their neighbors.
Catmull-Clark Subdivision
Refines polygon meshes into smoother subdivision surfaces.
Quadric Error Mesh Simplification
Simplifies a mesh by collapsing edges that add the least quadric error.
Explicit Integration
Advances simulation state using derivatives evaluated at the current time.
Constraint Projection
Enforces simulation constraints by projecting invalid state back onto the allowed manifold.
Verlet Constraint Solver
Maintains distance constraints by repeatedly correcting Verlet-integrated particle positions.
Broad Phase Collision Detection
Quickly finds possible colliding object pairs before exact collision tests.
Narrow Phase Collision Detection
Performs precise collision tests for candidate pairs found by broad phase.
Sweep and Prune
Reduces collision candidates by sorting bounding-box intervals along one or more axes.
GJK Collision Detection
Tests convex shapes for intersection using support points of their Minkowski difference.
Expanding Polytope Algorithm
Computes penetration depth and contact normal after GJK detects convex overlap.
Sequential Impulse Solver
Approximates rigid-body contact and joint constraints by applying clamped impulses one constraint at a time.
Boids Flocking
Simulates flocking from local separation, alignment, and cohesion rules.
Lattice Boltzmann Method
Simulates fluids by evolving particle distribution functions on a lattice.
Particle-in-Cell
Combines moving particles with a grid used to solve field quantities.
Finite Element Method
Approximates continuum behavior by solving equations over mesh elements.
Finite Volume Fluid Simulation
Simulates fluids by conserving quantities across cell boundaries.
QR Decomposition
Factors a matrix into an orthogonal matrix and an upper triangular matrix.
Singular Value Decomposition
Factors a matrix into singular vectors and singular values that reveal its main directions.
Power Iteration
Approximates the dominant eigenvector by repeatedly multiplying by a matrix.
Trapezoidal Rule
Approximates an integral by summing trapezoid areas under sampled function values.
Polynomial Interpolation
Finds a polynomial that passes through a set of sample points.
Lagrange Interpolation
Builds an interpolating polynomial as a weighted sum of basis polynomials.
Newton Interpolation
Builds an interpolating polynomial incrementally with divided differences.
Finite Volume Method
Solves conservation laws by balancing fluxes through control-volume boundaries.
Euler-Maruyama Method
Approximates stochastic differential equations with an Euler step plus random noise.
Runge-Kutta-Fehlberg
Solves ODEs with paired Runge-Kutta estimates used for adaptive step sizing.
Adams-Bashforth Method
Solves ODEs with an explicit multistep formula using previous derivative values.
Backward Differentiation Formula
Solves stiff ODEs with implicit multistep formulas based on backward differences.
Successive Over-Relaxation
Accelerates Gauss-Seidel iteration by over-relaxing each variable update.
Preconditioned Conjugate Gradient
Solves symmetric positive definite systems faster by applying a preconditioner.
MSAA
Reduces geometric aliasing by sampling coverage multiple times per pixel.
ReSTIR Sampling
Reuses light samples with reservoir sampling to improve direct lighting estimates.
Russian Roulette Path Termination
Randomly terminates low-contribution light paths while preserving an unbiased estimator.
Importance Sampling BRDF
Samples BRDF directions with a matching PDF so Monte Carlo paths spend more work on likely scattering directions.
BVH Traversal
Tests rays against a hierarchy of bounding volumes before testing contained geometry.
Mipmapping
Samples prefiltered texture levels so distant surfaces avoid aliasing and cache waste.
Normal Mapping
Adds lighting detail by perturbing shading normals from a texture instead of changing geometry.
Parallax Occlusion Mapping
Offsets texture coordinates by ray-marching through a height field on the surface.
Shadow Volumes
Creates extruded volumes from occluders to identify pixels in shadow.
Variance Shadow Maps
Stores depth moments so shadow maps can be filtered with probabilistic bounds.
Cook-Torrance Shading
Models specular reflection using microfacet surface behavior.
Phong Shading
Computes local lighting with ambient, diffuse, and specular terms per fragment.
Blinn-Phong Shading
Approximates specular highlights with a halfway vector between light and view directions.
Tone Mapping
Maps high-dynamic-range color values into a displayable range.
Highest Response Ratio Next Scheduling
Highest Response Ratio Next Scheduling chooses jobs using priority, completion-time, or resource-availability rules.
Proportional Share Scheduling
Proportional Share Scheduling allocates service according to fairness or proportional-share rules.
Stride Scheduling
Stride Scheduling allocates service according to fairness or proportional-share rules.
Completely Fair Scheduler
Completely Fair Scheduler allocates service according to fairness or proportional-share rules.
Gang Scheduling
Gang Scheduling chooses jobs using priority, completion-time, or resource-availability rules.
Two-Level Scheduling
Two-Level Scheduling chooses jobs using priority, completion-time, or resource-availability rules.
Deadline Monotonic Scheduling
Deadline Monotonic Scheduling uses timing constraints to prioritize real-time work.
Slack Stealing Scheduling
Slack Stealing Scheduling uses timing constraints to prioritize real-time work.
Weighted Fair Queuing
Weighted Fair Queuing allocates service according to fairness or proportional-share rules.
Deficit Round Robin
Deficit Round Robin chooses jobs using priority, completion-time, or resource-availability rules.
Token Bucket Scheduling
Token Bucket Scheduling rate-limits work by accumulating or draining capacity over time.
Leaky Bucket Scheduling
Leaky Bucket Scheduling rate-limits work by accumulating or draining capacity over time.
Backfilling Scheduling
Backfilling Scheduling chooses jobs using priority, completion-time, or resource-availability rules.
Min-Min Scheduling
Min-Min Scheduling chooses jobs using priority, completion-time, or resource-availability rules.
Max-Min Scheduling
Max-Min Scheduling chooses jobs using priority, completion-time, or resource-availability rules.
HEFT Scheduling
HEFT Scheduling chooses jobs using priority, completion-time, or resource-availability rules.
List Scheduling
List Scheduling chooses jobs using priority, completion-time, or resource-availability rules.
Interval Scheduling
Interval Scheduling selects compatible intervals from overlapping candidates.
Weighted Interval Scheduling
Weighted Interval Scheduling selects compatible intervals from overlapping candidates.
Bin Packing First Fit
Bin Packing First Fit packs items into limited-capacity containers.
Bin Packing Best Fit
Bin Packing Best Fit packs items into limited-capacity containers.
Consistent Hashing Load Balancing
Consistent Hashing Load Balancing chooses jobs using priority, completion-time, or resource-availability rules.
Knuth Shuffle
Knuth Shuffle draws samples while controlling distribution, coverage, or variance.
PCG Random Number Generator
PCG Random Number Generator generates deterministic pseudorandom sequences from a seed.
Xorshift Random Number Generator
Xorshift Random Number Generator generates deterministic pseudorandom sequences from a seed.
Xoshiro Random Number Generator
Xoshiro Random Number Generator generates deterministic pseudorandom sequences from a seed.
SplitMix64
SplitMix64 generates deterministic pseudorandom sequences from a seed.
Middle Square Weyl Sequence
Middle Square Weyl Sequence places samples with low discrepancy for better coverage.
Ziggurat Algorithm
Ziggurat Algorithm draws samples while controlling distribution, coverage, or variance.
Marsaglia Polar Method
Marsaglia Polar Method draws samples while controlling distribution, coverage, or variance.
Knuth-Yao Sampling
Knuth-Yao Sampling draws samples while controlling distribution, coverage, or variance.
Systematic Sampling
Systematic Sampling draws samples while controlling distribution, coverage, or variance.
Cluster Sampling
Cluster Sampling draws samples while controlling distribution, coverage, or variance.
Bootstrap Resampling
Bootstrap Resampling reuses observed data to estimate uncertainty.
Jackknife Resampling
Jackknife Resampling reuses observed data to estimate uncertainty.
Sequential Importance Resampling
Sequential Importance Resampling reuses observed data to estimate uncertainty.
Slice Sampling
Slice Sampling samples from a probability distribution for estimation.
Hamiltonian Monte Carlo
Hamiltonian Monte Carlo samples from a probability distribution for estimation.
No-U-Turn Sampler
No-U-Turn Sampler draws samples while controlling distribution, coverage, or variance.
Quasi-Monte Carlo Integration
Quasi-Monte Carlo Integration samples from a probability distribution for estimation.
Canonical LR Parsing
Canonical LR Parsing uses grammar states and parse tables to recognize syntax.
SLR Parsing
SLR Parsing uses grammar states and parse tables to recognize syntax.
Recursive Ascent Parsing
Recursive Ascent Parsing turns grammar rules and token streams into structured syntax.
Precedence Climbing
Precedence Climbing turns grammar rules and token streams into structured syntax.
Left Recursion Elimination
Left Recursion Elimination turns grammar rules and token streams into structured syntax.
Left Factoring
Left Factoring turns grammar rules and token streams into structured syntax.
Panic Mode Error Recovery
Panic Mode Error Recovery recovers from syntax errors without abandoning the whole parse.
Phrase-Level Error Recovery
Phrase-Level Error Recovery recovers from syntax errors without abandoning the whole parse.
Incremental Parsing
Incremental Parsing turns grammar rules and token streams into structured syntax.
Island Parsing
Island Parsing turns grammar rules and token streams into structured syntax.
Scannerless Parsing
Scannerless Parsing turns grammar rules and token streams into structured syntax.
Lexical Tie-In Parsing
Lexical Tie-In Parsing turns grammar rules and token streams into structured syntax.
Abstract Syntax Tree Construction
Abstract Syntax Tree Construction turns grammar rules and token streams into structured syntax.
Parse Forest Construction
Parse Forest Construction turns grammar rules and token streams into structured syntax.
Attribute Grammar Evaluation
Attribute Grammar Evaluation turns grammar rules and token streams into structured syntax.
Syntax Directed Translation
Syntax Directed Translation turns grammar rules and token streams into structured syntax.
DFA Minimization
DFA Minimization builds or runs finite automata over tokens.
Regular Expression Derivative Parsing
Regular Expression Derivative Parsing builds or runs finite automata over tokens.
AES-GCM
AES-GCM encrypts data with a defined symmetric construction.
AES-CTR Mode
AES-CTR Mode encrypts data with a defined symmetric construction.
AES-CBC Mode
AES-CBC Mode encrypts data with a defined symmetric construction.
AES-XTS Mode
AES-XTS Mode encrypts data with a defined symmetric construction.
ChaCha20-Poly1305
ChaCha20-Poly1305 encrypts data with a defined symmetric construction.
CMAC
CMAC protects secrecy, integrity, or authenticity with a named cryptographic primitive.
Poly1305-AES
Poly1305-AES encrypts data with a defined symmetric construction.
Bcrypt
Bcrypt protects secrecy, integrity, or authenticity with a named cryptographic primitive.
PSS Signature Padding
PSS Signature Padding proves message authenticity with public-key verification.
OAEP Padding
OAEP Padding adapts public-key encryption or signatures to safer randomized encodings.
ElGamal Encryption
ElGamal Encryption protects secrecy, integrity, or authenticity with a named cryptographic primitive.
Schnorr Signature
Schnorr Signature proves message authenticity with public-key verification.
Pedersen Commitment
Pedersen Commitment binds a value while hiding it until it is opened.
Commit-Reveal Scheme
Commit-Reveal Scheme binds a value while hiding it until it is opened.
Threshold Signature Scheme
Threshold Signature Scheme proves message authenticity with public-key verification.
BLS Signature
BLS Signature proves message authenticity with public-key verification.
FAST Corner Detection
FAST Corner Detection detects repeatable local image features.
Harris Corner Detection
Harris Corner Detection detects repeatable local image features.
Shi-Tomasi Corner Detection
Shi-Tomasi Corner Detection detects repeatable local image features.
SIFT Feature Detection
SIFT Feature Detection detects repeatable local image features.
SURF Feature Detection
SURF Feature Detection detects repeatable local image features.
ORB Feature Detection
ORB Feature Detection detects repeatable local image features.
RANSAC Image Homography
RANSAC Image Homography transforms image pixels into features, masks, or restored output.
Otsu Thresholding
Otsu Thresholding separates pixels by intensity or local contrast.
Adaptive Thresholding
Adaptive Thresholding separates pixels by intensity or local contrast.
K-Means Image Segmentation
K-Means Image Segmentation partitions an image into meaningful regions.
Mean Shift Segmentation
Mean Shift Segmentation partitions an image into meaningful regions.
Region Growing
Region Growing transforms image pixels into features, masks, or restored output.
Active Contour Model
Active Contour Model partitions an image into meaningful regions.
Anisotropic Diffusion
Anisotropic Diffusion transforms image pixels into features, masks, or restored output.
Richardson-Lucy Deconvolution
Richardson-Lucy Deconvolution transforms image pixels into features, masks, or restored output.
Retinex Algorithm
Retinex Algorithm transforms image pixels into features, masks, or restored output.
Myers Bit-Vector Algorithm
Myers Bit-Vector Algorithm finds exact or approximate matches in text or sequences.
Ukkonen Edit Distance
Ukkonen Edit Distance scores how similar two strings, sets, or sequences are.
BK-Tree Search
BK-Tree Search finds exact or approximate matches in text or sequences.
N-Gram Matching
N-Gram Matching finds exact or approximate matches in text or sequences.
Cosine Similarity
Cosine Similarity scores how similar two strings, sets, or sequences are.
Jaccard Similarity
Jaccard Similarity scores how similar two strings, sets, or sequences are.
Dice Coefficient
Dice Coefficient scores how similar two strings, sets, or sequences are.
Soundex
Soundex finds exact or approximate matches in text or sequences.
Metaphone
Metaphone finds exact or approximate matches in text or sequences.
Damerau-Levenshtein Distance
Damerau-Levenshtein Distance scores how similar two strings, sets, or sequences are.
Optimal String Alignment
Optimal String Alignment aligns sequences with exact or approximate matches.
Sellers Algorithm
Sellers Algorithm finds exact or approximate matches in text or sequences.
BLAST Seed-and-Extend
BLAST Seed-and-Extend aligns sequences with exact or approximate matches.
FM-Index Search
FM-Index Search uses indexed text structure to speed pattern lookup.
Burrows-Wheeler Matching
Burrows-Wheeler Matching finds exact or approximate matches in text or sequences.
Karp-Miller-Rosenberg String Matching
Karp-Miller-Rosenberg String Matching finds exact or approximate matches in text or sequences.
Canonical Huffman Coding
Canonical Huffman Coding assigns compact codes to symbols or integers.
Adaptive Huffman Coding
Adaptive Huffman Coding assigns compact codes to symbols or integers.
Shannon-Fano Coding
Shannon-Fano Coding assigns compact codes to symbols or integers.
Tunstall Coding
Tunstall Coding reduces data size using coding, prediction, dictionary, or transform structure.
Frame of Reference Encoding
Frame of Reference Encoding reduces data size using coding, prediction, dictionary, or transform structure.
Patched Frame of Reference
Patched Frame of Reference reduces data size using coding, prediction, dictionary, or transform structure.
Run-Length Bit Packing Hybrid
Run-Length Bit Packing Hybrid reduces data size using coding, prediction, dictionary, or transform structure.
Predictive Image Coding
Predictive Image Coding reduces data size using coding, prediction, dictionary, or transform structure.
JPEG DCT Compression
JPEG DCT Compression transforms image blocks before quantization and entropy coding.
JPEG-LS
JPEG-LS transforms image blocks before quantization and entropy coding.
PNG Filtering
PNG Filtering reduces data size using coding, prediction, dictionary, or transform structure.
FLAC Linear Prediction
FLAC Linear Prediction encodes prediction errors instead of raw samples.
Context Mixing Compression
Context Mixing Compression reduces data size using coding, prediction, dictionary, or transform structure.
Uniform Binary Search
Uniform Binary Search uses ordering or monotonic structure to eliminate candidates.
Galloping Search
Galloping Search locates items by exploiting structure in the collection or search space.
Rotated Array Search
Rotated Array Search uses ordering or monotonic structure to eliminate candidates.
Peak Finding
Peak Finding uses ordering or monotonic structure to eliminate candidates.
Saddleback Search
Saddleback Search locates items by exploiting structure in the collection or search space.
Fractional Cascading
Fractional Cascading locates items by exploiting structure in the collection or search space.
KD-Tree Nearest Neighbor Search
KD-Tree Nearest Neighbor Search finds nearby points while pruning distant candidates.
Ball Tree Search
Ball Tree Search locates items by exploiting structure in the collection or search space.
Vantage-Point Tree Search
Vantage-Point Tree Search locates items by exploiting structure in the collection or search space.
Branch and Bound Nearest Neighbor
Branch and Bound Nearest Neighbor finds nearby points while pruning distant candidates.
Bloom Filter Membership Query
Bloom Filter Membership Query locates items by exploiting structure in the collection or search space.
Binary Search in Answer Space
Binary Search in Answer Space uses ordering or monotonic structure to eliminate candidates.
Bitonic Sort
Bitonic Sort sorts with a fixed comparison network suited to parallel execution.
Odd-Even Sort
Odd-Even Sort sorts with a fixed comparison network suited to parallel execution.
Odd-Even Merge Sort
Odd-Even Merge Sort sorts with a fixed comparison network suited to parallel execution.
Pancake Sort
Pancake Sort orders records with a named compare, partition, or distribution strategy.
Cycle Sort
Cycle Sort orders records with a named compare, partition, or distribution strategy.
Smoothsort
Smoothsort orders records with a named compare, partition, or distribution strategy.
Tournament Sort
Tournament Sort orders records with a named compare, partition, or distribution strategy.
Library Sort
Library Sort orders records with a named compare, partition, or distribution strategy.
Patience Sorting
Patience Sorting orders records with a named compare, partition, or distribution strategy.
American Flag Sort
American Flag Sort orders records with a named compare, partition, or distribution strategy.
Sample Sort
Sample Sort orders large or partitioned data by coordinating smaller sorted pieces.
Bron-Kerbosch Algorithm
Bron-Kerbosch Algorithm extracts structure such as components, tours, rankings, or closures from a graph.
PageRank
PageRank scores graph nodes by repeatedly propagating rank through directed links.
HITS Algorithm
HITS Algorithm scores or groups graph nodes by link structure.
Label Propagation Community Detection
Label Propagation Community Detection scores or groups graph nodes by link structure.
Louvain Method
Louvain Method extracts structure such as components, tours, rankings, or closures from a graph.
Girvan-Newman Algorithm
Girvan-Newman Algorithm extracts structure such as components, tours, rankings, or closures from a graph.
Tarjan Bridge-Finding Algorithm
Tarjan Bridge-Finding Algorithm extracts structure such as components, tours, rankings, or closures from a graph.
Chu-Liu-Edmonds Algorithm
Chu-Liu-Edmonds Algorithm extracts structure such as components, tours, rankings, or closures from a graph.
Gabow SCC Algorithm
Gabow SCC Algorithm extracts structure such as components, tours, rankings, or closures from a graph.
Lexicographic Breadth-First Search
Lexicographic Breadth-First Search extracts structure such as components, tours, rankings, or closures from a graph.
Maximum Cardinality Search
Maximum Cardinality Search extracts structure such as components, tours, rankings, or closures from a graph.
Transitive Closure
Transitive Closure extracts structure such as components, tours, rankings, or closures from a graph.
Weighted A*
Weighted A* finds routes through graphs, grids, or motion-planning spaces.
Lazy Theta*
Lazy Theta* guides route search with a heuristic score.
Anya Pathfinding
Anya Pathfinding finds routes through graphs, grids, or motion-planning spaces.
Block A*
Block A* finds routes through graphs, grids, or motion-planning spaces.
Subgoal Graph Pathfinding
Subgoal Graph Pathfinding finds routes through graphs, grids, or motion-planning spaces.
HPA*
HPA* finds routes through graphs, grids, or motion-planning spaces.
Incremental Dijkstra
Incremental Dijkstra updates paths efficiently as graph costs change.
Multi-Heuristic A*
Multi-Heuristic A* finds routes through graphs, grids, or motion-planning spaces.
Real-Time Adaptive A*
Real-Time Adaptive A* finds routes through graphs, grids, or motion-planning spaces.
Probabilistic Roadmap
Probabilistic Roadmap samples feasible states and connects them into paths.
Cartesian Tree
Cartesian Tree organizes data around a query, update, ordering, or approximation invariant.
Interval Tree
Interval Tree organizes data around a query, update, ordering, or approximation invariant.
Order Statistic Tree
Order Statistic Tree organizes data around a query, update, ordering, or approximation invariant.
Van Emde Boas Tree
Van Emde Boas Tree organizes data around a query, update, ordering, or approximation invariant.
Radix Tree
Radix Tree organizes data around a query, update, ordering, or approximation invariant.
Patricia Trie
Patricia Trie organizes data around a query, update, ordering, or approximation invariant.
Merkle Patricia Trie
Merkle Patricia Trie organizes data around a query, update, ordering, or approximation invariant.
Count-Min Sketch
Count-Min Sketch organizes data around a query, update, ordering, or approximation invariant.
HyperLogLog
HyperLogLog organizes data around a query, update, ordering, or approximation invariant.
Cuckoo Hash Table
Cuckoo Hash Table organizes data around a query, update, ordering, or approximation invariant.
Robin Hood Hashing
Robin Hood Hashing organizes data around a query, update, ordering, or approximation invariant.
Min-Max Heap
Min-Max Heap organizes data around a query, update, ordering, or approximation invariant.
Fibonacci Heap
Fibonacci Heap organizes data around a query, update, ordering, or approximation invariant.
Pairing Heap
Pairing Heap organizes data around a query, update, ordering, or approximation invariant.
Welzl's Minimum Enclosing Circle
Welzl's Minimum Enclosing Circle computes spatial relationships, shapes, or mesh changes from geometric predicates.
Andrew's Monotone Chain
Andrew's Monotone Chain computes spatial relationships, shapes, or mesh changes from geometric predicates.
Kirkpatrick-Seidel Algorithm
Kirkpatrick-Seidel Algorithm computes spatial relationships, shapes, or mesh changes from geometric predicates.
Plane Sweep Closest Pair
Plane Sweep Closest Pair computes spatial relationships, shapes, or mesh changes from geometric predicates.
Point Location in Triangulation
Point Location in Triangulation computes spatial relationships, shapes, or mesh changes from geometric predicates.
Polygon Boolean Operations
Polygon Boolean Operations computes spatial relationships, shapes, or mesh changes from geometric predicates.
Voronoi Relaxation
Voronoi Relaxation computes spatial relationships, shapes, or mesh changes from geometric predicates.
Lloyd's Algorithm
Lloyd's Algorithm computes spatial relationships, shapes, or mesh changes from geometric predicates.
Mesh Decimation
Mesh Decimation computes spatial relationships, shapes, or mesh changes from geometric predicates.
Half-Edge Mesh Traversal
Half-Edge Mesh Traversal computes spatial relationships, shapes, or mesh changes from geometric predicates.
Householder Transformation
Householder Transformation approximates a numerical solution with iterative or algebraic steps.
Givens Rotation
Givens Rotation approximates a numerical solution with iterative or algebraic steps.
Lanczos Algorithm
Lanczos Algorithm approximates a numerical solution with iterative or algebraic steps.
Arnoldi Iteration
Arnoldi Iteration approximates a numerical solution with iterative or algebraic steps.
Thomas Algorithm
Thomas Algorithm approximates a numerical solution with iterative or algebraic steps.
Richardson Iteration
Richardson Iteration approximates a numerical solution with iterative or algebraic steps.
Richardson Extrapolation
Richardson Extrapolation approximates a numerical solution with iterative or algebraic steps.
Neville's Algorithm
Neville's Algorithm approximates a numerical solution with iterative or algebraic steps.
Brent's Method
Brent's Method approximates a numerical solution with iterative or algebraic steps.
Bulirsch-Stoer Method
Bulirsch-Stoer Method approximates a numerical solution with iterative or algebraic steps.
Bessel Filter
Bessel Filter filters, models, or extracts features from sampled signals.
Elliptic Filter
Elliptic Filter filters, models, or extracts features from sampled signals.
Comb Filter
Comb Filter filters, models, or extracts features from sampled signals.
All-Pass Filter
All-Pass Filter filters, models, or extracts features from sampled signals.
Envelope Detection
Envelope Detection filters, models, or extracts features from sampled signals.
Zero-Crossing Rate
Zero-Crossing Rate filters, models, or extracts features from sampled signals.
Mel-Frequency Cepstral Coefficients
Mel-Frequency Cepstral Coefficients filters, models, or extracts features from sampled signals.
Linear Predictive Coding
Linear Predictive Coding filters, models, or extracts features from sampled signals.
Yule-Walker Method
Yule-Walker Method filters, models, or extracts features from sampled signals.
Wiener Deconvolution
Wiener Deconvolution filters, models, or extracts features from sampled signals.
Momentum Gradient Descent
Momentum Gradient Descent improves candidate solutions according to an objective function.
RMSProp
RMSProp improves candidate solutions according to an objective function.
Nesterov Accelerated Gradient
Nesterov Accelerated Gradient improves candidate solutions according to an objective function.
FISTA
FISTA improves candidate solutions according to an objective function.
Trust Region Method
Trust Region Method improves candidate solutions according to an objective function.
Augmented Lagrangian Method
Augmented Lagrangian Method improves candidate solutions according to an objective function.
Cutting Plane Method
Cutting Plane Method improves candidate solutions according to an objective function.
Subgradient Method
Subgradient Method improves candidate solutions according to an objective function.
Mirror Descent
Mirror Descent improves candidate solutions according to an objective function.
Frank-Wolfe Algorithm
Frank-Wolfe Algorithm improves candidate solutions according to an objective function.
Gaussian Naive Bayes
Gaussian Naive Bayes learns a predictive, clustering, representation, or policy model from data.
Multinomial Naive Bayes
Multinomial Naive Bayes learns a predictive, clustering, representation, or policy model from data.
Extra Trees
Extra Trees learns a predictive, clustering, representation, or policy model from data.
Isolation Forest
Isolation Forest learns a predictive, clustering, representation, or policy model from data.
One-Class SVM
One-Class SVM learns a predictive, clustering, representation, or policy model from data.
Self-Organizing Map
Self-Organizing Map learns a predictive, clustering, representation, or policy model from data.
Learning Vector Quantization
Learning Vector Quantization learns a predictive, clustering, representation, or policy model from data.
Label Propagation
Label Propagation learns a predictive, clustering, representation, or policy model from data.
Policy Gradient
Policy Gradient learns a predictive, clustering, representation, or policy model from data.
Actor-Critic Method
Actor-Critic Method learns a predictive, clustering, representation, or policy model from data.
SVGF Denoising
SVGF Denoising computes visibility, shading, filtering, or lighting for images.
Irradiance Caching
Irradiance Caching computes visibility, shading, filtering, or lighting for images.
Light Mapping
Light Mapping computes visibility, shading, filtering, or lighting for images.
Light Propagation Volumes
Light Propagation Volumes computes visibility, shading, filtering, or lighting for images.
Cascaded Shadow Maps
Cascaded Shadow Maps computes visibility, shading, filtering, or lighting for images.
Percentage-Closer Filtering
Percentage-Closer Filtering computes visibility, shading, filtering, or lighting for images.
Physically Based Shading
Physically Based Shading computes visibility, shading, filtering, or lighting for images.
Oren-Nayar Shading
Oren-Nayar Shading computes visibility, shading, filtering, or lighting for images.
Subsurface Scattering Approximation
Subsurface Scattering Approximation computes visibility, shading, filtering, or lighting for images.
Impulse-Based Collision Response
Impulse-Based Collision Response advances physical or agent state under forces, constraints, or collisions.
Penalty Method Collision Response
Penalty Method Collision Response advances physical or agent state under forces, constraints, or collisions.
Continuous Collision Detection
Continuous Collision Detection advances physical or agent state under forces, constraints, or collisions.
Stable Fluids
Stable Fluids advances physical or agent state under forces, constraints, or collisions.
FLIP Fluid Simulation
FLIP Fluid Simulation advances physical or agent state under forces, constraints, or collisions.
MPM Simulation
MPM Simulation advances physical or agent state under forces, constraints, or collisions.
Verlet Cloth Simulation
Verlet Cloth Simulation advances physical or agent state under forces, constraints, or collisions.
Projective Dynamics
Projective Dynamics advances physical or agent state under forces, constraints, or collisions.
Shape Matching Simulation
Shape Matching Simulation advances physical or agent state under forces, constraints, or collisions.
Position Based Rigid Bodies
Position Based Rigid Bodies advances physical or agent state under forces, constraints, or collisions.
Simple Tiled Model
Simple Tiled Model uses rules, noise, or constraints to synthesize repeatable generated content.
Recursive Backtracking Maze Generation
Recursive Backtracking Maze Generation uses rules, noise, or constraints to synthesize repeatable generated content.
Prim Maze Generation
Prim Maze Generation uses rules, noise, or constraints to synthesize repeatable generated content.
Kruskal Maze Generation
Kruskal Maze Generation uses rules, noise, or constraints to synthesize repeatable generated content.
Growing Tree Maze Algorithm
Growing Tree Maze Algorithm uses rules, noise, or constraints to synthesize repeatable generated content.
Perlin Worms
Perlin Worms uses rules, noise, or constraints to synthesize repeatable generated content.
Agent-Based City Generation
Agent-Based City Generation uses rules, noise, or constraints to synthesize repeatable generated content.
Road Network L-System
Road Network L-System uses rules, noise, or constraints to synthesize repeatable generated content.
Boruvka's Algorithm
Builds a minimum spanning tree by repeatedly adding each component's cheapest outgoing edge.
Reverse-Delete Algorithm
Builds a minimum spanning tree by deleting expensive edges that are not needed for connectivity.
Transitive Reduction
Removes directed edges that are implied by alternate paths while preserving reachability.
Warshall's Algorithm
Computes transitive closure by repeatedly allowing each vertex as an intermediate step.
Push-Relabel
Computes maximum flow by pushing excess flow from active vertices and raising vertex heights.
Capacity Scaling Max Flow
Capacity Scaling Max Flow addresses maximum flow by solving flow on large-capacity edges first and lowering the scale threshold.
Gomory-Hu Tree
Gomory-Hu Tree addresses all-pairs minimum cuts by building a cut-equivalent tree from repeated minimum cut computations.
Stoer-Wagner Min Cut
Stoer-Wagner Min Cut uses merging weighted vertices while tracking the cheapest phase cut for global minimum cut.
Karger's Min Cut
Karger's Min Cut addresses global minimum cut by randomly contracting edges until only two supernodes remain.
Edmonds' Blossom Algorithm
Edmonds' Blossom Algorithm uses shrinking odd cycles so augmenting paths can be found in non-bipartite graphs for general graph matching.
Bipartite Matching DFS
Bipartite Matching DFS uses searching for augmenting paths from unmatched left-side vertices for bipartite matching.
Gale-Shapley Algorithm
Gale-Shapley Algorithm uses letting one side propose while the other side keeps its best current proposal for stable matching.
Fleury's Algorithm
Fleury's Algorithm uses walking unused edges while avoiding bridges unless no alternative remains for eulerian cycle construction.
Hopcroft-Tarjan Planarity Test
Hopcroft-Tarjan Planarity Test addresses planarity detection by using depth-first search lowpoint structure to detect planarity obstructions.
Boyer-Myrvold Planarity Test
Boyer-Myrvold Planarity Test addresses planarity embedding by incrementally maintaining embedding constraints during depth-first traversal.
Planar Embedding
Planar Embedding addresses planar embedding construction by ordering edges around vertices so a planar graph can be drawn without crossings.
Fruchterman-Reingold Layout
Fruchterman-Reingold Layout uses balancing attractive edge forces and repulsive vertex forces for force-directed graph drawing.
Sugiyama Layered Drawing
Draws directed graphs in layers by ranking vertices, reducing crossings, and assigning coordinates.
Reingold-Tilford Tree Layout
Draws tidy rooted trees by positioning subtrees recursively while separating their contours.
Walker Tree Layout
Walker Tree Layout addresses tree drawing by extending tidy tree placement to variable-size nodes and general rooted trees.
Greedy Graph Coloring
Greedy Graph Coloring uses assigning each vertex the smallest available color in an ordering for vertex coloring.
DSATUR
DSATUR uses choosing the uncolored vertex with the highest saturation degree for vertex coloring.
Welsh-Powell Coloring
Welsh-Powell Coloring uses coloring vertices in descending degree order with the first available color for vertex coloring.
Misra-Gries Edge Coloring
Misra-Gries Edge Coloring addresses edge coloring by rotating fans around vertices to color edges with bounded extra colors.
Weisfeiler-Lehman Refinement
Refines graph vertex colors by repeatedly encoding each vertex's neighborhood color multiset.
VF2 Graph Isomorphism
Tests graph or subgraph isomorphism by backtracking over node mappings with feasibility pruning.
Nauty Canonical Labeling
Nauty Canonical Labeling addresses canonical graph labeling by partitioning and refining vertex sets to produce canonical graph forms.
Greedy Maximal Independent Set
Greedy Maximal Independent Set uses selecting a vertex and deleting its neighbors until no vertices remain for independent set approximation.
Biconnected Components
Finds maximal graph regions that stay connected after removing any one vertex.
Lengauer-Tarjan Dominators
Lengauer-Tarjan Dominators addresses dominator tree construction by combining DFS numbering with union-find style ancestor queries.
Johnson's Cycle Enumeration
Johnson's Cycle Enumeration addresses simple cycle enumeration by blocking and unblocking vertices to enumerate elementary directed cycles.
Chordal Graph Recognition
Chordal Graph Recognition addresses chordal graph recognition by checking whether maximum cardinality search produces a perfect elimination ordering.
RRT*
RRT* addresses motion planning by rewiring a rapidly-exploring random tree to improve path cost over time.
Visibility Graph Roadmap
Visibility Graph Roadmap handles shortest path among obstacles by connecting mutually visible obstacle vertices and searching the resulting graph.
0-1 BFS
Finds shortest paths in graphs whose edge weights are only 0 or 1.
Dial's Algorithm
Dial's Algorithm addresses shortest paths with small integer weights by using buckets instead of a heap for bounded nonnegative edge weights.
Eppstein K Shortest Paths
Eppstein K Shortest Paths addresses k shortest paths by building a sidetrack structure that enumerates paths after one shortest-path tree.
LRTA*
LRTA* addresses online pathfinding by updating heuristic estimates while acting one step at a time.
Conflict-Based Search
Conflict-Based Search addresses multi-agent pathfinding by splitting conflicts into constraints and solving constrained paths for each agent.
Safe Interval Path Planning
Safe Interval Path Planning addresses dynamic obstacle pathfinding by searching intervals when each state is safely traversable.
Lazy PRM
Lazy PRM addresses motion planning by building a probabilistic roadmap while deferring expensive collision checks.
RRT-Connect
RRT-Connect addresses motion planning by growing two random trees toward each other until they connect.
Anytime D*
Anytime D* addresses dynamic pathfinding by refining a repairable path while gradually tightening the heuristic bound.
Lifelong Dijkstra
Lifelong Dijkstra addresses dynamic shortest paths by reusing previous shortest-path information after edge cost changes.
Multi-Goal A*
Multi-Goal A* addresses multi-target pathfinding by searching toward the best among several goals using admissible goal estimates.
Dynamic Window Approach
Chooses robot velocity commands by simulating short feasible motions and scoring them.
DPLL
DPLL uses recursively assigning variables with unit propagation and backtracking for satisfiability.
CDCL
CDCL uses learning conflict clauses from implication graphs and backjumping to useful decision levels for satisfiability.
WalkSAT
Searches for a satisfying assignment by flipping variables in unsatisfied clauses.
Davis-Putnam Algorithm
Davis-Putnam Algorithm addresses satisfiability by eliminating variables by resolution before checking the remaining formula.
Unit Propagation
Simplifies SAT formulas by repeatedly assigning literals forced by unit clauses.
Pure Literal Elimination
Pure Literal Elimination handles satisfiability simplification by assigning variables that appear with only one polarity.
2-SAT Implication Graph
Solves 2-SAT by turning binary clauses into implications and checking strongly connected components.
0/1 Knapsack Dynamic Programming
Solves 0/1 knapsack by tabulating the best value for each item prefix and capacity.
Knapsack FPTAS
Knapsack FPTAS addresses knapsack approximation by scaling item values so dynamic programming runs in polynomial time.
Meet-in-the-Middle Knapsack
Meet-in-the-Middle Knapsack addresses knapsack optimization by enumerating half-instance sums and combining compatible partial solutions.
Branch-and-Bound Knapsack
Branch-and-Bound Knapsack uses pruning item-choice subtrees whose optimistic bound cannot beat the incumbent for knapsack optimization.
Hungarian Algorithm
Solves the assignment problem by maintaining dual labels and improving a minimum-cost matching.
Min-Cost Max-Flow
Finds a maximum feasible flow whose shipped units have minimum total cost.
Vertex Cover 2-Approximation
Vertex Cover 2-Approximation uses choosing both endpoints of uncovered edges to build a bounded cover for vertex cover approximation.
Branch-and-Bound Vertex Cover
Branch-and-Bound Vertex Cover addresses vertex cover by branching on uncovered edges and pruning covers that cannot improve the incumbent.
Greedy Set Cover
Approximates set cover by repeatedly choosing the set that covers the most uncovered elements per cost.
Algorithm X
Algorithm X uses choosing a constraint column and recursively trying rows that satisfy it for exact cover search.
Dancing Links
Dancing Links handles exact cover search by using linked-list removal and restoration to implement Algorithm X efficiently.
Branch-and-Bound Set Packing
Branch-and-Bound Set Packing addresses set packing by branching on compatible sets and bounding the best possible packing.
Local Search Set Packing
Local Search Set Packing addresses set packing by swapping sets in and out of a packing to improve objective value.
Held-Karp TSP
Solves exact TSP by dynamic programming over visited-city subsets and the current last city.
Christofides Algorithm
Builds a metric TSP tour within 3/2 of optimum using a tree, matching, and shortcutting.
Nearest Neighbor TSP
Nearest Neighbor TSP uses repeatedly visiting the nearest unvisited city for traveling salesperson heuristic.
2-Opt
2-Opt uses reversing crossing tour segments when the swap shortens the tour for traveling salesperson improvement.
Lin-Kernighan
Lin-Kernighan addresses traveling salesperson improvement by adaptively choosing k-edge exchanges that improve a tour.
Branch-and-Bound Maximum Clique
Branch-and-Bound Maximum Clique addresses maximum clique by branching on candidate vertices while bounding clique size with coloring.
Tomita Clique Algorithm
Tomita Clique Algorithm addresses maximum clique by using greedy coloring bounds to prune maximum-clique search.
Dreyfus-Wagner Steiner Tree
Dreyfus-Wagner Steiner Tree addresses steiner tree by combining terminal subsets with shortest-path distances.
Feedback Vertex Set Branching
Feedback Vertex Set Branching addresses feedback vertex set by branching on cycle vertices until the remaining graph is acyclic.
Minimum Feedback Arc Set Heuristic
Minimum Feedback Arc Set Heuristic addresses feedback arc set by ordering vertices to reduce backward edges in a directed graph.
Karmarkar's Algorithm
Karmarkar's Algorithm uses following a projective interior path toward an optimal linear-programming solution for linear programming.
Revised Simplex Method
Solves linear programs by updating a compact basis representation instead of a full tableau.
Strassen Algorithm
Multiplies matrices by replacing eight block multiplications with seven recursive products.
Coppersmith-Winograd Algorithm
Coppersmith-Winograd Algorithm addresses matrix multiplication by using algebraic tensor techniques to reduce asymptotic multiplication exponents.
Blocked Matrix Multiplication
Blocked Matrix Multiplication uses multiplying matrix tiles to improve cache locality for matrix multiplication.
Winograd Matrix Multiplication
Winograd Matrix Multiplication addresses matrix multiplication by rearranging products to reduce scalar multiplications.
Karatsuba Multiplication
Karatsuba Multiplication uses splitting numbers and replacing one recursive multiplication with additions for integer multiplication.
Toom-Cook Multiplication
Toom-Cook Multiplication addresses integer multiplication by evaluating number polynomials at points and interpolating the product.
FFT-Based Integer Multiplication
FFT-Based Integer Multiplication addresses integer multiplication by convolving digit blocks with a fast Fourier transform.
Schoolbook Multiplication
Multiplies numbers by forming digit-by-digit partial products and adding them by place value.
Burnikel-Ziegler Division
Burnikel-Ziegler Division addresses large integer division by splitting operands into blocks for recursive division.
Knuth Division Algorithm
Knuth Division Algorithm uses normalizing divisor digits and estimating quotient digits for multi-precision division.
Euclidean Algorithm
Computes the greatest common divisor of two integers by repeatedly taking remainders.
Extended Euclidean Algorithm
Computes a greatest common divisor together with coefficients satisfying Bezout's identity.
Binary GCD
Binary GCD uses using shifts and subtraction instead of division for greatest common divisor.
Chinese Remainder Theorem Algorithm
Combines compatible congruences into one solution modulo the product of the moduli.
Exponentiation by Squaring
Computes powers efficiently by repeatedly squaring the base and using the exponent's binary digits.
Sieve of Eratosthenes
Finds all primes up to a limit by repeatedly crossing out multiples of each discovered prime.
Sieve of Atkin
Sieve of Atkin addresses prime generation by using modular quadratic forms to mark candidate primes.
Bareiss Algorithm
Bareiss Algorithm uses performing fraction-free Gaussian elimination to keep intermediate values exact for determinant computation.
Laplace Expansion
Laplace Expansion uses expanding a determinant into cofactors along a row or column for determinant computation.
Ryser Formula
Ryser Formula addresses permanent computation by summing signed products over subsets of matrix columns.
Berkowitz Algorithm
Berkowitz Algorithm addresses characteristic polynomial by building determinant coefficients without division.
Neville's Algorithm
Neville's Algorithm addresses polynomial interpolation by recursively combining nearby interpolation values.
Clenshaw Algorithm
Clenshaw Algorithm addresses polynomial series evaluation by evaluating recurrence-defined polynomial expansions backward.
Brent's Method
Brent's Method uses combining bisection, secant, and inverse quadratic interpolation steps for root finding.
Ridders' Method
Ridders' Method addresses root finding by using exponential interpolation inside a bracketing interval.
Steffensen's Method
Steffensen's Method addresses root finding by accelerating fixed-point iteration with a finite-difference correction.
GMRES
GMRES uses minimizing residuals over a growing Krylov subspace for linear system solving.
MINRES
MINRES addresses symmetric linear system solving by minimizing residuals for symmetric systems without requiring positive definiteness.
BiCGSTAB
BiCGSTAB addresses nonsymmetric linear system solving by combining bi-conjugate gradients with residual smoothing.
Householder QR
Householder QR addresses qr decomposition by reflecting columns to zero out subdiagonal entries.
Kahan Summation
Kahan Summation addresses floating-point summation by tracking lost low-order bits as a compensation term.
Aitken Delta-Squared Process
Aitken Delta-Squared Process addresses convergence acceleration by using three successive estimates to extrapolate a faster limit.
Orientation Test
Determines whether three points make a left turn, right turn, or are collinear.
In-Circle Test
Tests whether a point lies inside, on, or outside the circumcircle of three oriented points.
Shewchuk Adaptive Predicates
Shewchuk Adaptive Predicates addresses robust geometric predicates by increasing arithmetic precision only when floating-point signs are uncertain.
Trapezoidal Map Point Location
Locates a query point in a planar subdivision using a trapezoidal decomposition and search DAG.
Kirkpatrick Point Location
Kirkpatrick Point Location addresses planar point location by building a hierarchy of simplified triangulations for logarithmic queries.
Straight Skeleton
Straight Skeleton addresses polygon offset structure by moving polygon edges inward and recording where wavefront events meet.
Voronoi-Based Medial Axis
Voronoi-Based Medial Axis addresses medial axis extraction by deriving central shape branches from Voronoi features.
Monotone Polygon Partitioning
Monotone Polygon Partitioning uses sweeping vertices to split a polygon into y-monotone pieces for polygon decomposition.
Hertel-Mehlhorn Convex Decomposition
Hertel-Mehlhorn Convex Decomposition addresses convex polygon decomposition by removing unnecessary triangulation diagonals while preserving convex pieces.
Bayazit Convex Decomposition
Bayazit Convex Decomposition addresses convex polygon decomposition by recursively splitting reflex vertices to create convex parts.
Visvalingam-Whyatt Simplification
Visvalingam-Whyatt Simplification handles polyline simplification by removing points with the smallest effective triangle area.
Hausdorff Distance
Measures the largest nearest-neighbor gap between two point sets or shapes.
Frechet Distance
Measures curve similarity while preserving the order of points along each curve.
Shape Context Matching
Shape Context Matching addresses shape matching by describing points by histograms of relative positions around them.
Procrustes Analysis
Aligns two point sets by choosing the translation, scale, and rotation that minimize squared error.
Topological Sweep
Topological Sweep addresses line arrangement traversal by sweeping an arrangement by maintaining a topological ordering instead of coordinates.
Zone Algorithm
Zone Algorithm addresses line arrangement update by walking the cells crossed by an inserted curve or line.
Incremental Line Arrangement Construction
Incremental Line Arrangement Construction addresses line arrangement construction by adding lines one at a time and updating affected cells.
Constrained Delaunay Triangulation
Constrained Delaunay Triangulation uses building Delaunay-like triangles while preserving required input edges for constrained triangulation.
Power Diagram
Power Diagram addresses weighted voronoi diagram by assigning points by weighted power distance instead of ordinary distance.
Configuration-Space Obstacle Construction
Configuration-Space Obstacle Construction addresses configuration-space construction by expanding obstacles by the robot shape to convert motion to point navigation.
Rotating Calipers Diameter
Finds the farthest pair of points on a convex polygon by scanning antipodal pairs.
Rotating Calipers Width
Rotating Calipers Width addresses polygon width by rotating support lines to find the minimum strip containing a convex polygon.
Rotating Calipers Antipodal Pairs
Rotating Calipers Antipodal Pairs addresses antipodal pair enumeration by advancing support vertices around a convex polygon.
Circle-Line Intersection
Finds where a line crosses, touches, or misses a circle.
Point-to-Segment Distance
Computes the shortest distance from a point to a finite line segment.
Orthogonal Range Search
Reports points inside an axis-aligned query rectangle or box.
Polygon Offset Curve
Polygon Offset Curve addresses polygon offsetting by shifting edges and resolving joins to expand or shrink a polygon.
Shortest Common Superstring Greedy
Shortest Common Superstring Greedy handles shortest common superstring by repeatedly merging strings with the largest overlap.
Overlap Graph Superstring
Overlap Graph Superstring addresses shortest common superstring by modeling string overlaps as a weighted graph path problem.
Ukkonen Suffix Tree Construction
Ukkonen Suffix Tree Construction uses maintaining active points and suffix links during online construction for suffix tree construction.
Suffix Automaton LCS
Finds a longest common substring by scanning one string through the suffix automaton of another.
Bit-Parallel Levenshtein
Bit-Parallel Levenshtein addresses edit distance by packing dynamic-programming columns into machine words.
Shift-And Algorithm
Uses bit masks to update all exact-match prefix states in parallel.
Shift-Or Algorithm
Performs exact string matching with bit masks that track unmatched pattern positions.
BNDM
BNDM addresses exact string matching by matching backward with a nondeterministic automaton encoded as bit masks.
Commentz-Walter
Commentz-Walter addresses multiple string matching by combining Boyer-Moore style shifts with trie-based pattern matching.
Galil-Seiferas
Galil-Seiferas addresses exact string matching by using periodicity structure to guarantee linear-time matching with constant space.
Two-Way String Matching
Searches exactly by splitting the pattern at a critical factorization and scanning in two directions.
Crochemore-Perrin
Crochemore-Perrin addresses exact string matching by applying two-way matching with maximal suffix computation.
Manber-Myers Suffix Array Construction
Manber-Myers Suffix Array Construction uses doubling prefix lengths and sorting suffix ranks iteratively for suffix array construction.
SA-IS Suffix Array Construction
SA-IS Suffix Array Construction addresses suffix array construction by inducing suffix order from recursively sorted LMS substrings.
Kasai LCP Algorithm
Computes the LCP array from a suffix array in linear time.
Prefix Function
Computes the longest proper border length for every prefix of a string.
Morris-Pratt
Morris-Pratt uses using prefix borders to avoid rechecking matched characters for exact string matching.
Horspool Algorithm
Finds exact string matches by shifting with the bad-character rule from the pattern's last position.
Sunday Quick Search
Searches for a pattern by shifting according to the character just after the current window.
Gotoh Algorithm
Gotoh Algorithm addresses affine-gap sequence alignment by using separate dynamic-programming states for opening and extending gaps.
Affine Gap Alignment
Affine Gap Alignment addresses sequence alignment by penalizing gap openings more than gap extensions.
Hirschberg Algorithm
Computes sequence alignment using divide and conquer to reduce memory.
Cuckoo Hashing
Resolves hash collisions by moving keys between multiple candidate buckets.
X-Fast Trie
X-Fast Trie addresses predecessor queries by hashing binary trie prefixes to search integer keys by level.
Y-Fast Trie
Y-Fast Trie addresses predecessor queries by combining x-fast trie representatives with balanced buckets.
Judy Array
Judy Array addresses sparse array storage by using adaptive trie nodes tuned for sparse integer keys.
Cover Tree
Cover Tree addresses nearest-neighbor search by organizing points in nested metric covers across distance scales.
BK-Tree
Indexes metric-space items by storing children at discrete distances from each node.
Binomial Heap
Maintains a mergeable priority queue as a forest of binomial trees.
Compressed Sparse Row
Stores a sparse matrix by keeping nonzero values, column indices, and row offsets.
Edge List Representation
Represents a graph as a list of edges, optionally with weights or other edge data.
Bitset Operations
Represents dense sets as machine-word bits so membership and set operations run in word-sized chunks.
Persistent Union-Find
Persistent Union-Find addresses versioned connectivity by recording parent and rank changes so older connectivity states remain queryable.
Balanced KD-Tree Construction
Builds a k-d tree by recursively splitting points near the median along alternating dimensions.
Approximate KD-Tree Search
Approximate KD-Tree Search addresses approximate nearest-neighbor search by pruning tree branches using distance bounds and an approximation tolerance.
Leftist Heap
Maintains a mergeable heap by keeping the shortest null path on the right spine.
Skew Heap
Maintains a self-adjusting mergeable heap by swapping children during every meld.
Euler Tour Tree
Euler Tour Tree addresses dynamic forest connectivity by representing each tree as a sequence maintained by a balanced tree.
Link-Cut Tree
Link-Cut Tree addresses dynamic tree path queries by using splay trees to expose and update root-to-node paths.
Miller-Rabin Primality Test
Tests whether an integer is probably prime by looking for modular witnesses of compositeness.
Pollard's Rho Factorization
Finds a nontrivial factor by searching for cycles in a pseudorandom modular sequence.
AKS Primality Test
AKS Primality Test addresses deterministic primality testing by checking polynomial congruences that characterize prime numbers.
Fermat Primality Test
Checks probable primality using Fermat's congruence for selected bases.
Montgomery Multiplication
Multiplies numbers modulo n without trial division by working in Montgomery form.
Barrett Reduction
Reduces large integers modulo a fixed n using a precomputed reciprocal approximation.
Modular Exponentiation
Computes large powers modulo an integer without constructing the full power.
HMAC-DRBG
Generates deterministic random bits by updating HMAC-based internal state.
CTR-DRBG
Generates deterministic random bits with a block-cipher counter construction.
Hash-DRBG
Generates deterministic random bits by iterating a cryptographic hash over internal state.
Fortuna PRNG
Fortuna PRNG addresses cryptographic random generation by collecting entropy pools and reseeding a generator conservatively.
Fiat-Shamir Transform
Turns some interactive public-coin proofs into noninteractive proofs by hashing the transcript.
Lamport One-Time Signature
Signs one message by revealing selected one-time secret values for its digest bits.
Merkle Signature Scheme
Merkle Signature Scheme addresses hash-based signatures by authenticating many one-time public keys with a Merkle tree.
DSA
Signs message digests with modular arithmetic over a subgroup and a per-signature nonce.
ElGamal Signature
Signs messages with a discrete-log construction using a fresh random nonce.
LZ78
Compresses by emitting dictionary references while growing a phrase dictionary from the input stream.
LZSS
Compresses by choosing between literal bytes and LZ77-style back-references.
Context Tree Weighting
Context Tree Weighting addresses predictive compression by mixing predictions from contexts of different depths.
Context Mixing
Context Mixing addresses predictive compression by combining many model predictions into an arithmetic coder.
PAQ Compression
PAQ Compression addresses predictive compression by using context mixing and adaptive models for high compression ratios.
Sequitur Compression
Sequitur Compression addresses grammar-based compression by building a context-free grammar by replacing repeated digrams.
Re-Pair Compression
Re-Pair Compression addresses grammar-based compression by repeatedly replacing the most frequent adjacent symbol pair.
rANS Coding
rANS Coding addresses asymmetric numeral systems by encoding symbols by updating an integer state according to symbol frequencies.
Earliest Due Date Scheduling
Orders jobs by due date to reduce lateness-oriented scheduling risk.
Least Slack Time Scheduling
Prioritizes the ready task with the least time cushion before its deadline.
Critical Ratio Scheduling
Critical Ratio Scheduling addresses production scheduling by prioritizing jobs by time remaining divided by work remaining.
Highest Response Ratio Next
Chooses the ready job with the largest ratio of waiting time plus service time to service time.
Moore-Hodgson Algorithm
Minimizes the number of late jobs on a single machine by dropping the longest job from overloaded prefixes.
Workload Backfilling
Workload Backfilling addresses cluster scheduling by running smaller jobs early when they do not delay reserved larger jobs.
Shortest Remaining Time First
Preemptively runs the ready job with the smallest remaining processing time.
Erdos-Renyi Graph Generation
Generates a random graph by independently including possible edges with fixed probability.
Barabasi-Albert Model
Generates scale-free-style networks by preferentially attaching new nodes to high-degree nodes.
Watts-Strogatz Model
Generates small-world networks by rewiring a regular ring lattice with some probability.
Configuration Model
Configuration Model addresses degree-constrained graph generation by matching random degree stubs to produce a graph with a target degree sequence.
Randomized Rounding
Turns fractional optimization values into integral choices using probabilities derived from the fractional solution.
Alias Table Construction
Preprocesses a discrete distribution so weighted samples can be drawn in constant time.
Hopcroft DFA Minimization
Minimizes a DFA by repeatedly splitting state partitions with distinguishing transitions.
Brzozowski DFA Minimization
Brzozowski DFA Minimization addresses finite-state machine minimization by reversing and determinizing the automaton twice.
LR(1) Item Set Construction
Builds canonical LR(1) parser states from grammar items with lookahead symbols.
GLL Parsing
GLL Parsing addresses general context-free parsing by using graph-structured stacks to explore multiple parse paths.
Recursive Transition Network
Recursive Transition Network addresses grammar-driven parsing by representing grammar rules as transition graphs that call one another.
HOG Feature Descriptor
Describes local image shape by accumulating gradient-orientation histograms over cells.
SIFT
Detects and describes scale-invariant image keypoints from local gradient structure.
SURF
SURF addresses fast feature detection by approximating Hessian responses with integral-image box filters.
ORB
Detects oriented FAST keypoints and describes them with rotated binary BRIEF-style tests.
RANSAC Homography Estimation
Estimates a planar homography while rejecting mismatched feature correspondences.
Gaussian Process Regression
Predicts a continuous target with a Gaussian process posterior over functions.
Gaussian Process Classification
Gaussian Process Classification addresses bayesian classification by using a Gaussian process latent function with a classification likelihood.
Matrix Factorization
Approximates a data matrix as a product of lower-dimensional latent factor matrices.
Word2Vec Skip-Gram
Learns word embeddings by predicting nearby context words from a center word.
Barnes-Hut Simulation
Approximates many-body forces by grouping distant bodies in a spatial tree.
Fast Multipole Method
Fast Multipole Method addresses approximate n-body simulation by expanding far-field interactions and translating multipole summaries.
Verlet Neighbor List
Caches nearby particle pairs so neighbor searches can be reused across several simulation steps.
Depth Peeling
Depth Peeling addresses order-independent transparency by rendering successive depth layers from front to back.
Order-Independent Transparency
Renders transparent fragments without requiring a single global depth-sorted draw order.
Natural Merge Sort
Natural Merge Sort addresses adaptive sorting by detecting existing sorted runs and merging them.
Flashsort
Flashsort addresses distribution sorting by classifying elements into buckets by estimated value distribution.
Floyd-Rivest Selection
Selects the kth order statistic by sampling to narrow the partition range.
Levinson-Durbin Recursion
Solves Toeplitz linear systems from autocorrelation values using a stable recursive update.
Burg's Method
Burg's Method addresses autoregressive spectral estimation by estimating reflection coefficients by minimizing forward and backward prediction errors.
Wang Tiles
Generates tiled patterns by matching edge colors between neighboring tiles.
Truchet Tiles
Generates decorative patterns by rotating or selecting simple tile motifs.
Cuthill-McKee Algorithm
Orders sparse matrix graph vertices to reduce matrix bandwidth.
Reverse Cuthill-McKee Algorithm
Reverses Cuthill-McKee ordering to improve sparse matrix bandwidth profiles.
Range Tree
Supports orthogonal range queries with a layered balanced-tree structure.
Chinese Postman Algorithm
Finds a minimum-cost closed walk that traverses every edge of a graph.
Kernighan-Lin Algorithm
Improves a graph bisection by swapping vertex pairs to reduce cut cost.
Fiduccia-Mattheyses Algorithm
Refines network or graph partitions with efficient single-vertex moves.
Heap's Algorithm
Generates permutations by recursively swapping elements.
Steinhaus-Johnson-Trotter Algorithm
Generates permutations so adjacent outputs differ by one adjacent swap.
Bitmask Subset Enumeration
Enumerates subsets by treating integers as bit masks.