typescript-dsa-stl 2.8.0 → 3.0.0

package/README.md

@@ -18,7 +18,7 @@ STL-style data structures and algorithms for TypeScript: **Vector**, **Stack**,
 | [Collections](#collections) | Deque, nested vectors, multi-map / multi-set |
 | [Segment trees](#segment-trees) | Overview, variants, and examples (one section) |
 | [Graph algorithms](#graph-algorithms) | Adjacency lists, BFS/DFS, topological sort, components, MST, shortest paths |
-| [String algorithms](#string-algorithms) | KMP, Rabin–Karp, rolling hash |
+| [String algorithms](#string-algorithms) | KMP, Rabin–Karp, Trie, rolling hash |
 | [For maintainers](#for-maintainers) | Build and publish |
 | [License](#license) | MIT |
 
@@ -49,6 +49,7 @@ import {
   topologicalSortIndegree,
   KnuthMorrisPratt,
   RabinKarp,
+  Trie,
   StringRollingHash,
 } from 'typescript-dsa-stl/algorithms';
 import { clamp, range } from 'typescript-dsa-stl/utils';
@@ -166,15 +167,15 @@ range(0, 5);            // [0, 1, 2, 3, 4]
 | Area | Exports |
 |------|---------|
 | **Collections** | `Vector`, `Stack`, `Queue`, `Deque`, `List`, `ListNode`, `PriorityQueue`, `OrderedMap`, `UnorderedMap`, `OrderedSet`, `UnorderedSet`, `OrderedMultiMap`, `OrderedMultiSet`, `GeneralSegmentTree`, `SegmentTree`, `SegmentTreeSum`, `SegmentTreeMin`, `SegmentTreeMax`, `LazySegmentTreeSum`, `WeightedEdge`, `AdjacencyList`, `WeightedAdjacencyList`, `createAdjacencyList`, `createWeightedAdjacencyList`, `addEdge`, `deleteEdge` |
-| **Algorithms** | `sort`, `find`, `findIndex`, `transform`, `filter`, `reduce`, `reverse`, `unique`, `binarySearch`, `lowerBound`, `upperBound`, `min`, `max`, `partition`, `DisjointSetUnion`, `KnuthMorrisPratt`, `RabinKarp`, `RABIN_KARP_DEFAULT_MODS`, `StringRollingHash`, `breadthFirstSearch`, `depthFirstSearch`, `topologicalSortStack`, `topologicalSortIndegree`, `connectedComponents`, `kruskalMST`, `dijkstra`, `reconstructPath` |
+| **Algorithms** | `sort`, `find`, `findIndex`, `transform`, `filter`, `reduce`, `reverse`, `unique`, `binarySearch`, `lowerBound`, `upperBound`, `min`, `max`, `partition`, `DisjointSetUnion`, `KnuthMorrisPratt`, `RabinKarp`, `Trie`, `RABIN_KARP_DEFAULT_MODS`, `StringRollingHash`, `breadthFirstSearch`, `depthFirstSearch`, `topologicalSortStack`, `topologicalSortIndegree`, `connectedComponents`, `kruskalMST`, `dijkstra`, `bellmanFord`, `floydWarshall`, `reconstructPath`, `reconstructFloydWarshallPath` |
 | **Utils** | `clamp`, `range`, `noop`, `identity`, `swap` |
-| **Types** | `Comparator`, `Predicate`, `UnaryFn`, `Reducer`, `IterableLike`, `toArray`, `RabinKarpTripleMods`, `WeightedUndirectedEdge`, `TopologicalSortResult`, `GeneralSegmentTreeConfig`, `SegmentCombine`, `SegmentMerge`, `SegmentLeafBuild` |
+| **Types** | `Comparator`, `Predicate`, `UnaryFn`, `Reducer`, `IterableLike`, `toArray`, `RabinKarpTripleMods`, `WeightedUndirectedEdge`, `TopologicalSortResult`, `BellmanFordResult`, `FloydWarshallResult`, `GeneralSegmentTreeConfig`, `SegmentCombine`, `SegmentMerge`, `SegmentLeafBuild` |
 
 ### Subpath imports (tree-shaking)
 
 ```ts
 import { Vector, Stack, Queue, Deque } from 'typescript-dsa-stl/collections';
-import { sort, binarySearch, breadthFirstSearch, depthFirstSearch, topologicalSortStack, topologicalSortIndegree, KnuthMorrisPratt, RabinKarp, StringRollingHash } from 'typescript-dsa-stl/algorithms';
+import { sort, binarySearch, breadthFirstSearch, depthFirstSearch, topologicalSortStack, topologicalSortIndegree, dijkstra, bellmanFord, floydWarshall, KnuthMorrisPratt, RabinKarp, Trie, StringRollingHash } from 'typescript-dsa-stl/algorithms';
 import { clamp, range } from 'typescript-dsa-stl/utils';
 import type { Comparator } from 'typescript-dsa-stl/types';
 ```
@@ -277,23 +278,23 @@ cube.at(0).at(1).at(0);  // 3  (layer 0, row 1, col 0)
 
 ### OrderedMultiMap and OrderedMultiSet — use cases
 
-**OrderedMultiSet** is a sorted collection that allows duplicate elements (like C++ `std::multiset`). Use it when you need ordering and multiple copies of the same value.
+**OrderedMultiSet** keeps values sorted and allows duplicates.
 
 | Use case | Example |
 |----------|---------|
-| **Sorted runs / leaderboard with ties** | Store scores; multiple users can have the same score. Iterate in sorted order, use `count(score)` for ties. |
-| **Event timeline with repeated timestamps** | Add events by time; several events can share the same time. `add(timestamp)`, iterate in order. |
-| **K-th smallest in a multiset** | Keep elements sorted; k-th element is at index `k - 1` in iteration. |
-| **Range counts** | Combined with binary search ideas: count elements in `[low, high]` using `count` and iteration. |
+| **Leaderboard with ties** | Store repeated scores and iterate sorted. |
+| **Timeline with duplicate times** | Keep events sorted even with same timestamp. |
+| **K-th smallest** | Iterate sorted values and pick index `k - 1`. |
+| **Range stats** | Count values inside `[low, high]`. |
 
-**OrderedMultiMap** maps one key to multiple values while keeping keys sorted (like C++ `std::multimap`). Use it when a key can have several associated values and you need key order.
+**OrderedMultiMap** stores multiple values per key while keeping keys sorted.
 
 | Use case | Example |
 |----------|---------|
-| **Inverted index** | Key = term, values = document IDs containing that term. `set(term, docId)` for each occurrence; `getAll(term)` returns all doc IDs. |
-| **Grouping by key** | Key = category, values = items. `set(category, item)`; iterate keys in order, use `getAll(key)` per group. |
-| **One-to-many relations** | Key = user ID, values = session IDs. `set(userId, sessionId)`; `getAll(userId)` lists all sessions. |
-| **Time-series by bucket** | Key = time bucket, values = events. Sorted keys give chronological buckets; `getAll(bucket)` gets events in that bucket. |
+| **Inverted index** | `term -> docIds`. |
+| **Grouping** | `category -> items`. |
+| **One-to-many mapping** | `userId -> sessionIds`. |
+| **Time buckets** | `bucket -> events`, in key order. |
 
 **OrderedMultiSet example:**
 
@@ -329,9 +330,7 @@ for (const [key, value] of index) {
 
 ### Segment tree overview and complexity
 
-A segment tree is an indexable array backed by a tree so **range questions** (sum, min, max, or your own combine) and **updates** cost **O(log n)** instead of scanning the whole slice.
-
-Segment trees support **range queries** and **point updates** in **O(log n)**. Range endpoints are **inclusive**: `query(l, r)` covers indices `l` through `r`.
+A segment tree supports fast **range queries** and **updates**. For this package, ranges are inclusive: `query(l, r)`.
 
 **What each type does:**
 
@@ -344,7 +343,7 @@ Segment trees support **range queries** and **point updates** in **O(log n)**. R
 
 | Structure | Build | Point update | Range query | Extra |
 |-----------|-------|--------------|-------------|--------|
-| **GeneralSegmentTree**, **SegmentTree**, **SegmentTreeSum** / **Min** / **Max** | O(n) | O(log n) | O(log n) | Inclusive `[l, r]`; **GeneralSegmentTree** keeps raw `V` and uses `merge` + `buildLeaf` |
+| **GeneralSegmentTree**, **SegmentTree**, **SegmentTreeSum** / **Min** / **Max** | O(n) | O(log n) | O(log n) | Inclusive `[l, r]`; `GeneralSegmentTree` uses raw `V` + summary `T` |
 | **LazySegmentTreeSum** | O(n) | `set`: O(log n) | `rangeSum`: O(log n) | `rangeAdd` on a range: O(log n) |
 
 ### Segment tree: Sum, Min, Max and example
@@ -353,7 +352,7 @@ Segment trees support **range queries** and **point updates** in **O(log n)**. R
 - **`SegmentTreeMin`** — answers “what is the **minimum** in `[l, r]`?” after single-index updates.
 - **`SegmentTreeMax`** — answers “what is the **maximum** in `[l, r]`?” after single-index updates.
 
-Together they are fixed numeric implementations: build from initial values, **`update(i, value)`** for one index, **`query(l, r)`** for an inclusive range.
+These are fixed numeric trees with `update(i, value)` and inclusive `query(l, r)`.
 
 ```ts
 import {
@@ -374,7 +373,7 @@ const mx = new SegmentTreeMax([5, 2, 8, 1]);
 console.log(mx.query(0, 3)); // 8
 ```
 
-**Example — analytics / reporting (fixed buckets, range totals, single-day corrections):** each index is a **fixed bucket** (hour, day, version slot, …). You ask for the **sum** from bucket `a` through `b` and sometimes **fix one bucket** after late data or reconciliation — same API as above, wrapped for clarity.
+**Example use case:** fixed buckets (day/hour), range totals, and single-bucket corrections.
 
 ```ts
 import { SegmentTreeSum } from 'typescript-dsa-stl';
@@ -404,11 +403,11 @@ january.setDay(2, 1150); // corrected day 2
 console.log(january.totalBetweenDay(1, 3)); // sum over days 1..3
 ```
 
-In production you would usually **persist** the underlying series in a database and **rebuild** the tree when the period reloads; the tree stays useful in memory for dashboards, simulations, or request handlers that see heavy read/update traffic on the same window.
+In production, persist raw values and rebuild the tree when the period reloads.
 
 ### Generic SegmentTree
 
-**`SegmentTree<T>`** supports range queries for **any associative operation** (gcd, concatenation, bitwise OR, …) on a fixed-length array, with **point updates**, when element type and aggregate type are the same — pass an **associative** `combine` and a **neutral** value for query ranges that miss a segment (e.g. `0` for sum, `Infinity` for min).
+**`SegmentTree<T>`** supports any associative combine (gcd, concat, bitwise OR, etc.) with point updates. Provide `combine` and a neutral value.
 
 ```ts
 import { SegmentTree } from 'typescript-dsa-stl';
@@ -440,13 +439,13 @@ console.log(strTree.query(0, 2)); // 'abc'
 
 ### GeneralSegmentTree
 
-**`GeneralSegmentTree<T, V>`** keeps **raw** values of type **V** in the array while each segment stores a **different** summary type **T** (e.g. raw numbers in the array, but nodes keep sums of squares or custom stats).
+**`GeneralSegmentTree<T, V>`** keeps raw values as `V` and segment summaries as `T`.
 
-You supply:
+You provide:
 
-- **`merge(left, right)`** — combine two child aggregates (internal nodes).
-- **`neutral`** — identity for `merge` when a query does not overlap a segment.
-- **`buildLeaf(value, index)`** — build the leaf from the raw array on initial construction and on every `update`.
+- **`merge(left, right)`**: combine child summaries.
+- **`neutral`**: identity for non-overlapping ranges.
+- **`buildLeaf(value, index)`**: build a leaf from raw `V`.
 
 ```ts
 import { GeneralSegmentTree } from 'typescript-dsa-stl';
@@ -464,9 +463,9 @@ console.log(st.rawAt(1)); // 4 — current raw value at index 1
 
 ### LazySegmentTreeSum and example
 
-**`LazySegmentTreeSum`** maintains a numeric array where you can **add a constant to every element in a range**, **overwrite one cell**, and query **range sums** — all in **O(log n)** via lazy propagation (unlike the trees above, which only support point updates).
+**`LazySegmentTreeSum`** supports range add, point set, and range sum in **O(log n)** using lazy propagation.
 
-**`rangeAdd(l, r, delta)`** adds `delta` to every element in the inclusive range. **`rangeSum(l, r)`** returns the sum. **`set(i, value)`** assigns one position (lazy tags are applied along the path). All are **O(log n)** — see the complexity table in the overview above.
+`rangeAdd(l, r, delta)` updates a whole range, `rangeSum(l, r)` queries a range, and `set(i, value)` updates one index.
 
 ```ts
 import { LazySegmentTreeSum } from 'typescript-dsa-stl';
@@ -478,7 +477,7 @@ lazy.set(0, 100);
 console.log(lazy.rangeSum(0, 3)); // 100 + 5 + 5 + 0
 ```
 
-**Example — bulk adjustment on a slice, then aggregate:** apply the **same delta** to **every** element in an index range (bonuses, prorated credits, simulation shocks), then query **range sums** without updating each cell one by one.
+**Example use case:** apply one delta to a range, then query subtotals.
 
 ```ts
 import { LazySegmentTreeSum } from 'typescript-dsa-stl';
@@ -499,17 +498,17 @@ function simulateBulkBonusAndSubtotal(seatCount: number): void {
 simulateBulkBonusAndSubtotal(100);
 ```
 
-The same idea applies to **inventory deltas** across bin ranges, **loyalty points** batch credits by user-ID band (when IDs map to contiguous indices), or **game/simulation** state where many cells gain the same buff and you query partial totals.
+Same pattern works for inventory ranges, loyalty batches, and simulation buffs.
 
 ---
 
 ## Graph algorithms
 
-Graph helpers live on the main package and under `typescript-dsa-stl/collections` for adjacency types and factories.
+Graph helpers are available from the main package and `typescript-dsa-stl/collections`.
 
 ### Adjacency list (like C++ `vector<vector<type>> graph(n)`)
 
-You can model C++-style adjacency lists using the graph types and helpers exported from `typescript-dsa-stl/collections` (or the main package).
+Use these types/helpers to model C++-style adjacency lists.
 
 #### Unweighted adjacency list
 
@@ -589,31 +588,19 @@ deleteEdge(graph, u, v, w);      // delete all edges u -> v with weight w
 
 #### Graph adjacency list — use cases
 
-Use an **unweighted** graph (adjacency list) when you only care about connectivity; use a **weighted** graph when edges have costs (distance, time, capacity).
+Use **unweighted** lists for connectivity/traversal; use **weighted** lists when edges have costs.
 
 | Use case | When to use |
 |----------|-------------|
-| **BFS / DFS, connectivity** | Unweighted: shortest path in terms of hop count, connected components, cycle detection. |
-| **Shortest path (Dijkstra), MST** | Weighted: edge weights as distances or costs; run Dijkstra, Prim, or Kruskal on the list. |
-| **Social / dependency graphs** | Unweighted or weighted: followers, dependencies (e.g. build order), recommendation graphs. |
-| **Grid / game graphs** | Unweighted: 4- or 8-neighbor grids; weighted if movement costs differ per cell. |
-| **Network / flow** | Weighted: capacities or latencies on edges for max-flow or routing. |
+| **BFS / DFS, connectivity** | Unweighted hop-based traversal and components. |
+| **Shortest path, MST** | Weighted edges for distance/cost problems. |
+| **Social / dependency graphs** | Use either, depending on whether edges have weights. |
+| **Grid / game graphs** | Unweighted for equal moves; weighted for variable move cost. |
+| **Network / flow** | Weighted capacity/latency models. |
 
 ### Breadth-first search (BFS) and depth-first search (DFS)
 
-`breadthFirstSearch` and `depthFirstSearch` take the number of vertices `n`, an unweighted `AdjacencyList`, and a `start` vertex. They return the **visit order** for all vertices **reachable** from `start` (vertices outside that component are not included). For an undirected graph, add each edge in **both** directions (see `addEdge` below).
-
-**Example graph (diamond):** edges `0—1`, `0—2`, `1—3`, `2—3`.
-
-```text
-      0
-     / \
-    1   2
-     \ /
-      3
-```
-
-With neighbors listed in ascending vertex id (`0: [1,2]`, `1: [0,3]`, …), **BFS** from `0` visits by increasing distance from `0`: first `0`, then `1` and `2`, then `3` → order `[0, 1, 2, 3]`. **DFS** (preorder, first neighbor in each list first) goes `0 → 1 → 3` then `2` → order `[0, 1, 3, 2]`. The exact DFS order depends on how you order each adjacency list.
+`breadthFirstSearch` and `depthFirstSearch` take `n`, an unweighted `AdjacencyList`, and `start`. They return traversal order for vertices reachable from `start`.
 
 ```ts
 import {
@@ -626,7 +613,6 @@ import {
 const n = 4;
 const graph = createAdjacencyList(n);
 
-// Undirected diamond: add both directions for each edge
 addEdge(graph, 0, 1);
 addEdge(graph, 1, 0);
 addEdge(graph, 0, 2);
@@ -636,55 +622,17 @@ addEdge(graph, 3, 1);
 addEdge(graph, 2, 3);
 addEdge(graph, 3, 2);
 
-const start = 0;
-
-// BFS: level-by-level from start (hop count); output: [0, 1, 2, 3]
-console.log(breadthFirstSearch(n, graph, start));
-// Expected console output: [ 0, 1, 2, 3 ]
-
-// DFS: preorder with explicit stack; output: [0, 1, 3, 2] for this adjacency layout
-console.log(depthFirstSearch(n, graph, start));
-// Expected console output: [ 0, 1, 3, 2 ]
-
-// Invalid start → empty traversal
-console.log(breadthFirstSearch(n, graph, -1)); // []
-console.log(depthFirstSearch(n, graph, n)); // []
-
-// Vertex 4 isolated: BFS/DFS from 0 never visits 4
-const withIsolated = createAdjacencyList(5);
-addEdge(withIsolated, 0, 1);
-addEdge(withIsolated, 1, 0);
-console.log(breadthFirstSearch(5, withIsolated, 0)); // [0, 1] — not [0,1,2,3,4]
+console.log(breadthFirstSearch(n, graph, 0)); // [0, 1, 2, 3]
+console.log(depthFirstSearch(n, graph, 0));   // [0, 1, 3, 2]
 ```
 
-**Notes**
-
-- **Directed graphs:** only list outgoing edges in `adj[u]`; traversal follows arcs from `start`.
-- **Disconnected graphs:** run again from another unvisited `start`, or use `connectedComponents` to enumerate components first.
-- **Weighted graphs:** for traversal ignoring weights, use the same vertex lists as the unweighted graph (weights are ignored by these two functions).
+For undirected graphs, add both directions. DFS order depends on neighbor order.
 
 ### Topological sort
 
-`topologicalSortStack` (iterative DFS / finish order) and `topologicalSortIndegree` (Kahn’s algorithm, zero-indegree queue) both take `n` and a **directed** unweighted `AdjacencyList`. They return `{ order, ok }`: a permutation of `0..n-1` when `ok` is true, or failure when a directed cycle exists.
-
-**When to use**
-
-- **Task / build / dependency ordering:** items must happen only after their prerequisites (package install order, compile steps, course prerequisites).
-- **Scheduling under precedence constraints:** jobs with “A before B” rules and no cycles.
-- **Detecting cycles in a directed model:** if `ok` is false, the graph (on valid vertices `0..n-1`) is not a DAG.
-- **Pick either algorithm:** both answer the same yes/no; choose **stack** if you want DFS-style behavior and an explicit stack; choose **indegree** (Kahn) if you prefer peeling sources level-by-level (often closer to “ready queue” mental models).
-
-**When topological order is not possible**
+`topologicalSortStack` (DFS-style) and `topologicalSortIndegree` (Kahn) take `n` and a directed unweighted `AdjacencyList`. Both return `{ order, ok }`.
 
-- Any **directed cycle** (including a **self-loop**): `ok` is false.
-- **Undirected** graphs modeled with **both** `u → v` and `v → u`: that is a 2-cycle, so **not** a DAG unless you only use directed edges that reflect real precedence.
-
-**Example (how to call it and use the result)**
-
-Both functions return the same shape: **`TopologicalSortResult`** — `{ order: number[]; ok: boolean }`.
-
-- **`ok === true`:** `order` is a **permutation of `0..n-1`**; every edge `u → v` appears with `u` before `v` in `order`.
-- **`ok === false`:** **no** full topological order exists (directed cycle). For `topologicalSortStack`, `order` is `[]`. For `topologicalSortIndegree`, `order` may list only some vertices; **do not** treat it as a complete sort.
+Use it for dependency ordering. If `ok` is `false`, the graph has a cycle.
 
 ```ts
 import {
@@ -702,81 +650,22 @@ addEdge(g, 0, 2);
 addEdge(g, 1, 3);
 addEdge(g, 2, 3);
 
-// Whole result (typed)
-const result: TopologicalSortResult = topologicalSortStack(n, g);
-
-// Usually destructure
-const { order, ok } = topologicalSortIndegree(n, g);
-
-if (ok) {
-  // `order` here is from `topologicalSortIndegree` above → [0, 1, 2, 3] for this graph.
-
-  // 1) See the whole sequence at once
-  console.log(order);
-  // → [ 0, 1, 2, 3 ]   (Node.js / browser consoles may add line breaks or “Array(4)” styling)
-
-  // 2) How many steps (same as n when ok is true)
-  console.log(order.length);
-  // → 4
-
-  // 3) Pick by position: first task, second task, …
-  const first = order[0];
-  const second = order[1];
-  console.log('do vertex', first, 'before', second);
-  // → do vertex 0 before 1
-
-  // 4) Simple loop with indices
-  for (let i = 0; i < order.length; i++) {
-    console.log('step', i + 1, '→ vertex', order[i]);
-  }
-  // → step 1 → vertex 0
-  // → step 2 → vertex 1
-  // → step 3 → vertex 2
-  // → step 4 → vertex 3
-
-  // 5) Same loop, shorter (when you only need the vertex id)
-  for (const vertex of order) {
-    console.log('run job for vertex', vertex);
-  }
-  // → run job for vertex 0
-  // → run job for vertex 1
-  // → run job for vertex 2
-  // → run job for vertex 3
-
-  // 6) Optional: each number is an index into your own list of names
-  const jobNames = ['bootstrap', 'compileA', 'compileB', 'link'];
-  const readable = order.map((vertex) => jobNames[vertex]);
-  console.log(readable.join(' → '));
-  // → bootstrap → compileA → compileB → link
-} else {
-  // No valid order exists (cycle). Use a flag, return early, or show an error.
-  console.error('Graph has a cycle; cannot topologically sort.');
-  // → Graph has a cycle; cannot topologically sort.
-  //   (often printed on stderr; some runtimes prepend “Error” styling)
-}
-
-// Compare algorithms (same `ok` on a given graph; `order` may differ)
-const a = topologicalSortStack(n, g);
+const a: TopologicalSortResult = topologicalSortStack(n, g);
 const b = topologicalSortIndegree(n, g);
-console.log(a.ok, b.ok);
-// → true true
-//   (here `a.order` is [0, 2, 1, 3] and `b.order` is [0, 1, 2, 3] — both valid)
+console.log(a.ok, a.order);
+console.log(b.ok, b.order);
 
-// Cycle: 0 → 1 → 2 → 0
 const cyclic = createAdjacencyList(3);
 addEdge(cyclic, 0, 1);
 addEdge(cyclic, 1, 2);
 addEdge(cyclic, 2, 0);
 const bad = topologicalSortStack(3, cyclic);
-console.log(bad.ok);
-// → false
-console.log(bad.order);
-// → []
+console.log(bad.ok, bad.order); // false, []
 ```
 
 ### Disjoint Set Union (Union-Find)
 
-Use Union-Find (DSU) to compute connected components efficiently. It merges endpoints of every edge in the adjacency list, so for directed graphs it returns weak connectivity components.
+Use DSU to compute connected components. For directed graphs, this gives weakly connected components.
 
 ```ts
 import { createAdjacencyList, connectedComponents } from 'typescript-dsa-stl';
@@ -794,7 +683,7 @@ const comps = connectedComponents(n, graph);
 
 #### Traverse the result
 
-`connectedComponents(n, adj)` returns `number[][]` where each inner array is a component (list of vertices).
+`connectedComponents(n, adj)` returns `number[][]` (one vertex list per component).
 
 ```ts
 // 1) Iterate each component
@@ -811,7 +700,7 @@ const sizes = comps.map(comp => comp.length);
 
 ### Kruskal MST (uses DSU)
 
-For a weighted graph, `kruskalMST` builds a Minimum Spanning Tree (MST) using DSU.
+For weighted graphs, `kruskalMST` builds a minimum spanning tree with DSU.
 
 ```ts
 import {
@@ -835,7 +724,7 @@ const { edges, totalWeight } = kruskalMST(n, wGraph, { undirected: true });
 
 #### Traverse the MST
 
-`kruskalMST(...)` returns `{ edges, totalWeight }`. To traverse the MST like a graph, convert `edges` into an adjacency list:
+`kruskalMST(...)` returns `{ edges, totalWeight }`. Convert `edges` to an adjacency list to traverse it.
 
 ```ts
 import { createWeightedAdjacencyList } from 'typescript-dsa-stl/collections';
@@ -856,7 +745,7 @@ for (const { to, weight } of mstAdj[0]) {
 
 ### Dijkstra shortest paths
 
-`dijkstra` computes single-source shortest paths on a **weighted** graph with **non-negative** edge weights.
+`dijkstra` computes single-source shortest paths on weighted graphs with non-negative edges.
 It returns:
 
 - `dist[v]`: shortest distance from `start` to `v` (`Infinity` if unreachable)
@@ -886,30 +775,67 @@ const path = reconstructPath(prev, 0, target); // [0, ..., target] or [] if unre
 console.log(path); // [0, 1, 2, 4]
 ```
 
+### Bellman-Ford shortest paths
+
+`bellmanFord` computes single-source shortest paths with negative edges allowed and reports reachable negative cycles.
+
+```ts
+import { createWeightedAdjacencyList, addEdge, bellmanFord, reconstructPath } from 'typescript-dsa-stl';
+
+const n = 4;
+const g = createWeightedAdjacencyList(n);
+addEdge(g, 0, 1, 1);
+addEdge(g, 1, 2, -2);
+addEdge(g, 2, 3, 2);
+
+const { dist, prev, hasNegativeCycle } = bellmanFord(n, g, 0);
+console.log(dist, hasNegativeCycle); // [0, 1, -1, 1], false
+console.log(reconstructPath(prev, 0, 3)); // [0, 1, 2, 3]
+```
+
+### Floyd-Warshall all-pairs shortest paths
+
+`floydWarshall` computes all-pairs shortest paths and includes a `next` matrix for path reconstruction.
+
+```ts
+import {
+  createWeightedAdjacencyList,
+  addEdge,
+  floydWarshall,
+  reconstructFloydWarshallPath,
+} from 'typescript-dsa-stl';
+
+const n = 4;
+const g = createWeightedAdjacencyList(n);
+addEdge(g, 0, 1, 3);
+addEdge(g, 1, 2, 1);
+addEdge(g, 0, 2, 10);
+addEdge(g, 2, 3, 2);
+
+const { dist, next, hasNegativeCycle } = floydWarshall(n, g);
+console.log(dist[0][3], hasNegativeCycle); // 6, false
+console.log(reconstructFloydWarshallPath(next, 0, 3)); // [0, 1, 2, 3]
+```
+
 ---
 
 ## String algorithms
 
-### Knuth–Morris–Pratt (KMP), Rabin–Karp, and string rolling hash
+### Knuth–Morris–Pratt (KMP), Rabin–Karp, Trie, and string rolling hash
 
-All three work on **UTF-16 code units** (same as `String` indexing). They solve **different jobs**: KMP and Rabin–Karp are **pattern matchers** (list all start indices of a pattern in a text). `StringRollingHash` is a **substring-hash tool** on a **fixed** string—you combine it with your own logic (equality checks, binary search, etc.).
+All four operate on UTF-16 code units: KMP/Rabin–Karp for pattern matching, `Trie` for exact/prefix lookup, `StringRollingHash` for substring hashes.
 
 #### When to use which
 
 | Goal | Prefer | Why |
 |------|--------|-----|
-| **Find every occurrence** of **one pattern** in **one text**, with **worst-case** O(n + m), **no hashing**, predictable behaviour | **KnuthMorrisPratt** | LPS table; only character comparisons; no modular arithmetic. |
-| **Find every occurrence** of a pattern using a **sliding window** and **hashes** (triple moduli + final verify) | **RabinKarp** | Same asymptotic average case; good when you think in rolling hashes or batch **same-length** patterns. |
-| **Many O(1) hash queries** on **substrings of one string** you already hold (compare two ranges, palindrome / LCP style checks, rolling checks without slicing) | **StringRollingHash** | O(n) preprocess, O(1) per `substringHash`; **not** a drop-in “find all matches” API—use KMP or Rabin–Karp for that. |
-
-**Concrete situations**
-
-- **Use KMP** when you need a **guaranteed** linear scan (interviews, strict time bounds, large alphabets), or the pattern is **reused** across many searches (`new KnuthMorrisPratt(pattern)` once, `.search(text)` many times).
-- **Use Rabin–Karp** when a **rolling hash** model fits (e.g. one long stream, one pattern), or you later generalize to **several patterns of the same length** (compare each pattern’s triple hash to each window hash). Triple hashing keeps false hash positives negligible; **verification** still guarantees correct indices.
-- **Use `StringRollingHash`** when the problem is **“hash of s[l..r)”** many times on **one** `s`—e.g. check `s[i..i+k) === s[j..j+k)` via hash equality (then confirm if needed), or algorithms that **binary search** on length using substring hashes. For **only** “list all starts of P in T”, pick **KMP** or **Rabin–Karp** instead of building substring hashes by hand.
+| **Single-pattern matching with predictable worst-case** | **KnuthMorrisPratt** | Linear time, no hashing. |
+| **Rolling-hash style matching** | **RabinKarp** | Window hashes + final verify. |
+| **Dynamic dictionary / prefix queries** | **Trie** | `insert`/`search`/`startsWith` in O(L). |
+| **Many substring hash queries on one string** | **StringRollingHash** | O(n) preprocess, O(1) per query. |
 
 ```ts
-import { KnuthMorrisPratt, RabinKarp, StringRollingHash } from 'typescript-dsa-stl';
+import { KnuthMorrisPratt, RabinKarp, Trie, StringRollingHash } from 'typescript-dsa-stl';
 
 // A) Pattern fixed, searched in many buffers — build KMP once, call .search() repeatedly (LPS reused).
 const multiDoc = new KnuthMorrisPratt('ERROR');
@@ -921,24 +847,29 @@ const hay = '...long text...';
 KnuthMorrisPratt.findOccurrences(hay, 'needle');
 new RabinKarp('needle').search(hay);
 
-// C) Same static string, many range-equality checks — rolling hash (not for “find all pattern starts” by itself).
+// C) Dictionary/prefix queries — Trie.
+const trie = new Trie();
+trie.insert('apple');
+trie.insert('app');
+trie.search('app');       // true
+trie.startsWith('appl');  // true
+trie.delete('app');       // true
+
+// D) Same static string, many range-equality checks — rolling hash (not for “find all pattern starts” by itself).
 const s = 'banana';
 const rh = new StringRollingHash(s);
 // Does s[1..4) equal s[3..6)? (both length 3)
 const maybe = rh.substringHash(1, 3) === rh.substringHash(3, 3); // then compare slices if you need certainty
 ```
 
-**How KMP works:** Build an LPS (longest proper prefix that is also a suffix) table for the pattern, then scan the text once. On a mismatch, the LPS tells you how far to shift the pattern without moving the text pointer backward—**O(n + m)** time, **O(m)** extra space for the pattern’s LPS.
-
-**How Rabin–Karp works:** Use **triple hashing**—three independent polynomial hashes (same base, three distinct prime moduli, see `RABIN_KARP_DEFAULT_MODS`). A position is a candidate only when **all three** window hashes match the pattern’s triple; then a **character-by-character** check runs so reported matches are always correct. Spurious triple collisions are negligible; average **O(n + m)**.
-
-**How rolling hash works:** Precompute prefix hashes and powers of a base modulo a prime. The hash of any substring `s[start .. start + length)` is derived from two prefix values—**O(n)** build, **O(1)** per substring query. Hashes can collide; for critical equality checks, compare actual strings after a hash match.
+KMP and Rabin–Karp matching are linear in practice for this API; rolling hash is O(n) preprocess + O(1) substring hash query.
 
 ```ts
 import {
   KnuthMorrisPratt,
-  StringRollingHash,
   RabinKarp,
+  Trie,
+  StringRollingHash,
   RABIN_KARP_DEFAULT_MODS,
 } from 'typescript-dsa-stl';
 
@@ -975,6 +906,16 @@ console.log(RabinKarp.findOccurrences('aaaa', 'aa')); // [0, 1, 2]
 // Empty pattern: no matches
 console.log(new RabinKarp('').search('text')); // []
 
+// --- Trie: dictionary and prefix queries ---
+const trie = new Trie();
+trie.insert('apple');
+trie.insert('app');
+console.log(trie.search('app')); // true
+console.log(trie.search('ap')); // false
+console.log(trie.startsWith('ap')); // true
+console.log(trie.delete('app')); // true
+console.log(trie.search('app')); // false
+
 // --- String rolling hash: default base 131, mod 1_000_000_007 (both configurable) ---
 const rh = new StringRollingHash('hello');
 // Internally: prefix[] and pow[] so substring hashes are O(1)

package/dist/algorithms/graph.d.ts

@@ -75,6 +75,22 @@ export interface WeightedUndirectedEdge {
     v: number;
     weight: number;
 }
+export interface BellmanFordResult {
+    /** Shortest distance from `start` to each vertex (`Infinity` if unreachable). */
+    dist: number[];
+    /** Previous vertex on one shortest path tree (`-1` if none). */
+    prev: number[];
+    /** True if a negative cycle is reachable from `start`. */
+    hasNegativeCycle: boolean;
+}
+export interface FloydWarshallResult {
+    /** All-pairs shortest path distances (`Infinity` if unreachable). */
+    dist: number[][];
+    /** Next-hop matrix for path reconstruction (`-1` means no path). */
+    next: number[][];
+    /** True if at least one negative cycle exists in the graph. */
+    hasNegativeCycle: boolean;
+}
 /**
  * Connected components in an (unweighted) graph using DSU.
  * Complexity: O((n + m) * alpha(n)).
@@ -112,10 +128,30 @@ export declare function dijkstra(n: number, adj: WeightedAdjacencyList<number, n
     dist: number[];
     prev: number[];
 };
+/**
+ * Bellman-Ford single-source shortest paths on a weighted graph.
+ * Supports negative edge weights and reports if a reachable negative cycle exists.
+ *
+ * Complexity: O(n * m), where n = vertices and m = edges.
+ */
+export declare function bellmanFord(n: number, adj: WeightedAdjacencyList<number, number>, start: number): BellmanFordResult;
+/**
+ * Floyd-Warshall all-pairs shortest paths on a weighted graph.
+ * Handles negative edge weights, and reports if any negative cycle exists.
+ *
+ * Complexity: O(n^3) time, O(n^2) space.
+ */
+export declare function floydWarshall(n: number, adj: WeightedAdjacencyList<number, number>): FloydWarshallResult;
 /**
  * Reconstruct a path from a `prev` array (as returned by `dijkstra`).
  *
  * @returns an array of vertices from start to target (inclusive), or [] if unreachable.
  */
 export declare function reconstructPath(prev: readonly number[], start: number, target: number): number[];
+/**
+ * Reconstruct a path from `start` to `target` using Floyd-Warshall `next` matrix.
+ *
+ * @returns vertices from start to target (inclusive), or [] if unreachable/invalid.
+ */
+export declare function reconstructFloydWarshallPath(next: readonly (readonly number[])[], start: number, target: number): number[];
 //# sourceMappingURL=graph.d.ts.map

package/dist/algorithms/graph.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph.d.ts","sourceRoot":"","sources":["../../src/algorithms/graph.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAIpF;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAChC,CAAC,EAAE,MAAM,EACT,GAAG,EAAE,aAAa,CAAC,MAAM,CAAC,EAC1B,KAAK,EAAE,MAAM,GACZ,MAAM,EAAE,CAmBV;AAED;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAC9B,CAAC,EAAE,MAAM,EACT,GAAG,EAAE,aAAa,CAAC,MAAM,CAAC,EAC1B,KAAK,EAAE,MAAM,GACZ,MAAM,EAAE,CAiBV;AAED;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,qBAAqB;IACpC,8GAA8G;IAC9G,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,iHAAiH;IACjH,EAAE,EAAE,OAAO,CAAC;CACb;AAID;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,oBAAoB,CAClC,CAAC,EAAE,MAAM,EACT,GAAG,EAAE,aAAa,CAAC,MAAM,CAAC,GACzB,qBAAqB,CAoCvB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,uBAAuB,CACrC,CAAC,EAAE,MAAM,EACT,GAAG,EAAE,aAAa,CAAC,MAAM,CAAC,GACzB,qBAAqB,CA0BvB;AAED,MAAM,WAAW,sBAAsB;IACrC,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CACjC,CAAC,EAAE,MAAM,EACT,GAAG,EAAE,aAAa,CAAC,MAAM,CAAC,GACzB,MAAM,EAAE,EAAE,CAQZ;AAED;;;;;;GAMG;AACH,wBAAgB,UAAU,CACxB,CAAC,EAAE,MAAM,EACT,GAAG,EAAE,qBAAqB,CAAC,MAAM,EAAE,MAAM,CAAC,EAC1C,OAAO,CAAC,EAAE;IAAE,UAAU,CAAC,EAAE,OAAO,CAAA;CAAE,GACjC;IAAE,KAAK,EAAE,sBAAsB,EAAE,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAE,CAgC1D;AAED;;;;;;;;GAQG;AACH,wBAAgB,QAAQ,CACtB,CAAC,EAAE,MAAM,EACT,GAAG,EAAE,qBAAqB,CAAC,MAAM,EAAE,MAAM,CAAC,EAC1C,KAAK,EAAE,MAAM,EACb,OAAO,CAAC,EAAE;IAAE,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,GAC5B;IAAE,IAAI,EAAE,MAAM,EAAE,CAAC;IAAC,IAAI,EAAE,MAAM,EAAE,CAAA;CAAE,CAmCpC;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAC7B,IAAI,EAAE,SAAS,MAAM,EAAE,EACvB,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,GACb,MAAM,EAAE,CAgBV"}
+{"version":3,"file":"graph.d.ts","sourceRoot":"","sources":["../../src/algorithms/graph.ts"],"names":[],"mappings":"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"}

package/dist/algorithms/graph.js

@@ -256,6 +256,103 @@ export function dijkstra(n, adj, start, options) {
     }
     return { dist, prev };
 }
+/**
+ * Bellman-Ford single-source shortest paths on a weighted graph.
+ * Supports negative edge weights and reports if a reachable negative cycle exists.
+ *
+ * Complexity: O(n * m), where n = vertices and m = edges.
+ */
+export function bellmanFord(n, adj, start) {
+    const dist = Array(n).fill(Number.POSITIVE_INFINITY);
+    const prev = Array(n).fill(-1);
+    if (start < 0 || start >= n) {
+        return { dist, prev, hasNegativeCycle: false };
+    }
+    const edges = [];
+    for (let u = 0; u < n; u++) {
+        for (const e of adj[u] ?? []) {
+            const v = e.to;
+            if (v < 0 || v >= n)
+                continue;
+            edges.push({ u, v, w: e.weight });
+        }
+    }
+    dist[start] = 0;
+    for (let i = 0; i < n - 1; i++) {
+        let changed = false;
+        for (const { u, v, w } of edges) {
+            if (dist[u] === Number.POSITIVE_INFINITY)
+                continue;
+            const nd = dist[u] + w;
+            if (nd < dist[v]) {
+                dist[v] = nd;
+                prev[v] = u;
+                changed = true;
+            }
+        }
+        if (!changed)
+            break;
+    }
+    let hasNegativeCycle = false;
+    for (const { u, v, w } of edges) {
+        if (dist[u] === Number.POSITIVE_INFINITY)
+            continue;
+        if (dist[u] + w < dist[v]) {
+            hasNegativeCycle = true;
+            break;
+        }
+    }
+    return { dist, prev, hasNegativeCycle };
+}
+/**
+ * Floyd-Warshall all-pairs shortest paths on a weighted graph.
+ * Handles negative edge weights, and reports if any negative cycle exists.
+ *
+ * Complexity: O(n^3) time, O(n^2) space.
+ */
+export function floydWarshall(n, adj) {
+    const dist = Array.from({ length: n }, () => Array(n).fill(Number.POSITIVE_INFINITY));
+    const next = Array.from({ length: n }, () => Array(n).fill(-1));
+    for (let i = 0; i < n; i++) {
+        dist[i][i] = 0;
+        next[i][i] = i;
+    }
+    for (let u = 0; u < n; u++) {
+        for (const e of adj[u] ?? []) {
+            const v = e.to;
+            const w = e.weight;
+            if (v < 0 || v >= n)
+                continue;
+            if (w < dist[u][v]) {
+                dist[u][v] = w;
+                next[u][v] = v;
+            }
+        }
+    }
+    for (let k = 0; k < n; k++) {
+        for (let i = 0; i < n; i++) {
+            if (dist[i][k] === Number.POSITIVE_INFINITY)
+                continue;
+            for (let j = 0; j < n; j++) {
+                if (dist[k][j] === Number.POSITIVE_INFINITY)
+                    continue;
+                const nd = dist[i][k] + dist[k][j];
+                if (nd < dist[i][j]) {
+                    dist[i][j] = nd;
+                    next[i][j] = next[i][k];
+                }
+            }
+        }
+    }
+    let hasNegativeCycle = false;
+    for (let i = 0; i < n; i++) {
+        if (dist[i][i] < 0) {
+            hasNegativeCycle = true;
+            break;
+        }
+    }
+    return { dist, next, hasNegativeCycle };
+}
 /**
  * Reconstruct a path from a `prev` array (as returned by `dijkstra`).
  *
@@ -283,4 +380,29 @@ export function reconstructPath(prev, start, target) {
     path.reverse();
     return path;
 }
+/**
+ * Reconstruct a path from `start` to `target` using Floyd-Warshall `next` matrix.
+ *
+ * @returns vertices from start to target (inclusive), or [] if unreachable/invalid.
+ */
+export function reconstructFloydWarshallPath(next, start, target) {
+    const n = next.length;
+    if (start < 0 || start >= n)
+        return [];
+    if (target < 0 || target >= n)
+        return [];
+    if ((next[start]?.[target] ?? -1) === -1)
+        return [];
+    const path = [start];
+    let cur = start;
+    for (let steps = 0; steps < n; steps++) {
+        if (cur === target)
+            return path;
+        cur = next[cur][target];
+        if (cur === -1)
+            return [];
+        path.push(cur);
+    }
+    return [];
+}
 //# sourceMappingURL=graph.js.map

package/dist/algorithms/graph.js.map

@@ -1 +1 @@
-{"version":3,"file":"graph.js","sourceRoot":"","sources":["../../src/algorithms/graph.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"graph.js","sourceRoot":"","sources":["../../src/algorithms/graph.ts"],"names":[],"mappings":"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"}

package/dist/algorithms/index.d.ts

@@ -3,7 +3,8 @@ export { DisjointSetUnion } from './disjointSetUnion.js';
 export { KnuthMorrisPratt } from './kmp.js';
 export { StringRollingHash } from './stringHashing.js';
 export { RabinKarp, RABIN_KARP_DEFAULT_MODS } from './rabinKarp.js';
+export { Trie } from './trie.js';
 export type { RabinKarpTripleMods } from './rabinKarp.js';
-export type { WeightedUndirectedEdge, TopologicalSortResult } from './graph.js';
-export { breadthFirstSearch, depthFirstSearch, topologicalSortStack, topologicalSortIndegree, connectedComponents, dijkstra, reconstructPath, kruskalMST, } from './graph.js';
+export type { WeightedUndirectedEdge, TopologicalSortResult, BellmanFordResult, FloydWarshallResult, } from './graph.js';
+export { breadthFirstSearch, depthFirstSearch, topologicalSortStack, topologicalSortIndegree, connectedComponents, dijkstra, bellmanFord, floydWarshall, reconstructPath, reconstructFloydWarshallPath, kruskalMST, } from './graph.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/algorithms/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/algorithms/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,IAAI,EACJ,IAAI,EACJ,SAAS,EACT,SAAS,EACT,MAAM,EACN,MAAM,EACN,OAAO,EACP,MAAM,EACN,YAAY,EACZ,UAAU,EACV,UAAU,EACV,GAAG,EACH,GAAG,EACH,SAAS,GACV,MAAM,YAAY,CAAC;AAEpB,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAC5C,OAAO,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AACvD,OAAO,EAAE,SAAS,EAAE,uBAAuB,EAAE,MAAM,gBAAgB,CAAC;AACpE,YAAY,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AAC1D,YAAY,EAAE,sBAAsB,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAChF,OAAO,EACL,kBAAkB,EAClB,gBAAgB,EAChB,oBAAoB,EACpB,uBAAuB,EACvB,mBAAmB,EACnB,QAAQ,EACR,eAAe,EACf,UAAU,GACX,MAAM,YAAY,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/algorithms/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,IAAI,EACJ,IAAI,EACJ,SAAS,EACT,SAAS,EACT,MAAM,EACN,MAAM,EACN,OAAO,EACP,MAAM,EACN,YAAY,EACZ,UAAU,EACV,UAAU,EACV,GAAG,EACH,GAAG,EACH,SAAS,GACV,MAAM,YAAY,CAAC;AAEpB,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAC5C,OAAO,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AACvD,OAAO,EAAE,SAAS,EAAE,uBAAuB,EAAE,MAAM,gBAAgB,CAAC;AACpE,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,YAAY,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AAC1D,YAAY,EACV,sBAAsB,EACtB,qBAAqB,EACrB,iBAAiB,EACjB,mBAAmB,GACpB,MAAM,YAAY,CAAC;AACpB,OAAO,EACL,kBAAkB,EAClB,gBAAgB,EAChB,oBAAoB,EACpB,uBAAuB,EACvB,mBAAmB,EACnB,QAAQ,EACR,WAAW,EACX,aAAa,EACb,eAAe,EACf,4BAA4B,EAC5B,UAAU,GACX,MAAM,YAAY,CAAC"}

package/dist/algorithms/index.js

@@ -3,5 +3,6 @@ export { DisjointSetUnion } from './disjointSetUnion.js';
 export { KnuthMorrisPratt } from './kmp.js';
 export { StringRollingHash } from './stringHashing.js';
 export { RabinKarp, RABIN_KARP_DEFAULT_MODS } from './rabinKarp.js';
-export { breadthFirstSearch, depthFirstSearch, topologicalSortStack, topologicalSortIndegree, connectedComponents, dijkstra, reconstructPath, kruskalMST, } from './graph.js';
+export { Trie } from './trie.js';
+export { breadthFirstSearch, depthFirstSearch, topologicalSortStack, topologicalSortIndegree, connectedComponents, dijkstra, bellmanFord, floydWarshall, reconstructPath, reconstructFloydWarshallPath, kruskalMST, } from './graph.js';
 //# sourceMappingURL=index.js.map

package/dist/algorithms/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/algorithms/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,IAAI,EACJ,IAAI,EACJ,SAAS,EACT,SAAS,EACT,MAAM,EACN,MAAM,EACN,OAAO,EACP,MAAM,EACN,YAAY,EACZ,UAAU,EACV,UAAU,EACV,GAAG,EACH,GAAG,EACH,SAAS,GACV,MAAM,YAAY,CAAC;AAEpB,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAC5C,OAAO,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AACvD,OAAO,EAAE,SAAS,EAAE,uBAAuB,EAAE,MAAM,gBAAgB,CAAC;AAGpE,OAAO,EACL,kBAAkB,EAClB,gBAAgB,EAChB,oBAAoB,EACpB,uBAAuB,EACvB,mBAAmB,EACnB,QAAQ,EACR,eAAe,EACf,UAAU,GACX,MAAM,YAAY,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/algorithms/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,IAAI,EACJ,IAAI,EACJ,SAAS,EACT,SAAS,EACT,MAAM,EACN,MAAM,EACN,OAAO,EACP,MAAM,EACN,YAAY,EACZ,UAAU,EACV,UAAU,EACV,GAAG,EACH,GAAG,EACH,SAAS,GACV,MAAM,YAAY,CAAC;AAEpB,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAC5C,OAAO,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AACvD,OAAO,EAAE,SAAS,EAAE,uBAAuB,EAAE,MAAM,gBAAgB,CAAC;AACpE,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAQjC,OAAO,EACL,kBAAkB,EAClB,gBAAgB,EAChB,oBAAoB,EACpB,uBAAuB,EACvB,mBAAmB,EACnB,QAAQ,EACR,WAAW,EACX,aAAa,EACb,eAAe,EACf,4BAA4B,EAC5B,UAAU,GACX,MAAM,YAAY,CAAC"}

package/dist/algorithms/trie.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Trie (prefix tree) for UTF-16 strings.
+ * Supports insert/search/prefix checks and word removal.
+ */
+export declare class Trie {
+    private readonly root;
+    constructor();
+    /** Insert a word into the trie. */
+    insert(word: string): void;
+    /** Returns true if the exact word exists in the trie. */
+    search(word: string): boolean;
+    /** Returns true if there is any inserted word with this prefix. */
+    startsWith(prefix: string): boolean;
+    /**
+     * Remove one exact word from the trie.
+     * Returns true when the word existed and was removed.
+     */
+    delete(word: string): boolean;
+    /** Returns true when no words have been inserted. */
+    isEmpty(): boolean;
+    private findNode;
+}
+//# sourceMappingURL=trie.d.ts.map

package/dist/algorithms/trie.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trie.d.ts","sourceRoot":"","sources":["../../src/algorithms/trie.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAOH,qBAAa,IAAI;IACf,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAW;;IAMhC,mCAAmC;IACnC,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAc1B,yDAAyD;IACzD,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAK7B,mEAAmE;IACnE,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO;IAInC;;;OAGG;IACH,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAwB7B,qDAAqD;IACrD,OAAO,IAAI,OAAO;IAIlB,OAAO,CAAC,QAAQ;CASjB"}

package/dist/algorithms/trie.js

@@ -0,0 +1,80 @@
+/**
+ * Trie (prefix tree) for UTF-16 strings.
+ * Supports insert/search/prefix checks and word removal.
+ */
+class TrieNode {
+    constructor() {
+        this.children = new Map();
+        this.isWord = false;
+    }
+}
+export class Trie {
+    constructor() {
+        this.root = new TrieNode();
+    }
+    /** Insert a word into the trie. */
+    insert(word) {
+        let node = this.root;
+        for (let i = 0; i < word.length; i++) {
+            const ch = word[i];
+            let next = node.children.get(ch);
+            if (!next) {
+                next = new TrieNode();
+                node.children.set(ch, next);
+            }
+            node = next;
+        }
+        node.isWord = true;
+    }
+    /** Returns true if the exact word exists in the trie. */
+    search(word) {
+        const node = this.findNode(word);
+        return node !== undefined && node.isWord;
+    }
+    /** Returns true if there is any inserted word with this prefix. */
+    startsWith(prefix) {
+        return this.findNode(prefix) !== undefined;
+    }
+    /**
+     * Remove one exact word from the trie.
+     * Returns true when the word existed and was removed.
+     */
+    delete(word) {
+        const path = [];
+        let node = this.root;
+        for (let i = 0; i < word.length; i++) {
+            const ch = word[i];
+            const next = node.children.get(ch);
+            if (!next)
+                return false;
+            path.push({ parent: node, ch, node: next });
+            node = next;
+        }
+        if (!node.isWord)
+            return false;
+        node.isWord = false;
+        // Prune nodes that are no longer needed.
+        for (let i = path.length - 1; i >= 0; i--) {
+            const segment = path[i];
+            if (segment.node.isWord || segment.node.children.size > 0)
+                break;
+            segment.parent.children.delete(segment.ch);
+        }
+        return true;
+    }
+    /** Returns true when no words have been inserted. */
+    isEmpty() {
+        return this.root.children.size === 0;
+    }
+    findNode(path) {
+        let node = this.root;
+        for (let i = 0; i < path.length; i++) {
+            const next = node.children.get(path[i]);
+            if (!next)
+                return undefined;
+            node = next;
+        }
+        return node;
+    }
+}
+//# sourceMappingURL=trie.js.map

package/dist/algorithms/trie.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"trie.js","sourceRoot":"","sources":["../../src/algorithms/trie.ts"],"names":[],"mappings":"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"}

package/dist/index.d.ts

@@ -7,8 +7,8 @@
  */
 export { Vector, Stack, Queue, Deque, List, ListNode, PriorityQueue, OrderedMap, UnorderedMap, OrderedSet, UnorderedSet, OrderedMultiSet, OrderedMultiMap, addEdge, deleteEdge, createAdjacencyList, createWeightedAdjacencyList, GeneralSegmentTree, SegmentTree, SegmentTreeSum, SegmentTreeMin, SegmentTreeMax, LazySegmentTreeSum, } from './collections/index.js';
 export type { WeightedEdge, AdjacencyList, WeightedAdjacencyList, GeneralSegmentTreeConfig, SegmentCombine, SegmentLeafBuild, SegmentMerge, } from './collections/index.js';
-export { sort, find, findIndex, transform, filter, reduce, reverse, unique, binarySearch, lowerBound, upperBound, min, max, partition, DisjointSetUnion, KnuthMorrisPratt, StringRollingHash, RabinKarp, RABIN_KARP_DEFAULT_MODS, breadthFirstSearch, depthFirstSearch, topologicalSortStack, topologicalSortIndegree, connectedComponents, dijkstra, reconstructPath, kruskalMST, } from './algorithms/index.js';
-export type { WeightedUndirectedEdge, RabinKarpTripleMods, TopologicalSortResult, } from './algorithms/index.js';
+export { sort, find, findIndex, transform, filter, reduce, reverse, unique, binarySearch, lowerBound, upperBound, min, max, partition, DisjointSetUnion, KnuthMorrisPratt, StringRollingHash, RabinKarp, Trie, RABIN_KARP_DEFAULT_MODS, breadthFirstSearch, depthFirstSearch, topologicalSortStack, topologicalSortIndegree, connectedComponents, dijkstra, bellmanFord, floydWarshall, reconstructPath, reconstructFloydWarshallPath, kruskalMST, } from './algorithms/index.js';
+export type { WeightedUndirectedEdge, RabinKarpTripleMods, TopologicalSortResult, BellmanFordResult, FloydWarshallResult, } from './algorithms/index.js';
 export { clamp, range, noop, identity, swap } from './utils/index.js';
 export type { Comparator, Predicate, UnaryFn, Reducer, IterableLike } from './types/index.js';
 export { toArray } from './types/index.js';

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EACL,MAAM,EACN,KAAK,EACL,KAAK,EACL,KAAK,EACL,IAAI,EACJ,QAAQ,EACR,aAAa,EACb,UAAU,EACV,YAAY,EACZ,UAAU,EACV,YAAY,EACZ,eAAe,EACf,eAAe,EACf,OAAO,EACP,UAAU,EACV,mBAAmB,EACnB,2BAA2B,EAC3B,kBAAkB,EAClB,WAAW,EACX,cAAc,EACd,cAAc,EACd,cAAc,EACd,kBAAkB,GACnB,MAAM,wBAAwB,CAAC;AAChC,YAAY,EACV,YAAY,EACZ,aAAa,EACb,qBAAqB,EACrB,wBAAwB,EACxB,cAAc,EACd,gBAAgB,EAChB,YAAY,GACb,MAAM,wBAAwB,CAAC;AAChC,OAAO,EACL,IAAI,EACJ,IAAI,EACJ,SAAS,EACT,SAAS,EACT,MAAM,EACN,MAAM,EACN,OAAO,EACP,MAAM,EACN,YAAY,EACZ,UAAU,EACV,UAAU,EACV,GAAG,EACH,GAAG,EACH,SAAS,EACT,gBAAgB,EAChB,gBAAgB,EAChB,iBAAiB,EACjB,SAAS,EACT,uBAAuB,EACvB,kBAAkB,EAClB,gBAAgB,EAChB,oBAAoB,EACpB,uBAAuB,EACvB,mBAAmB,EACnB,QAAQ,EACR,eAAe,EACf,UAAU,GACX,MAAM,uBAAuB,CAAC;AAC/B,YAAY,EACV,sBAAsB,EACtB,mBAAmB,EACnB,qBAAqB,GACtB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AACtE,YAAY,EAAE,UAAU,EAAE,SAAS,EAAE,OAAO,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAC9F,OAAO,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EACL,MAAM,EACN,KAAK,EACL,KAAK,EACL,KAAK,EACL,IAAI,EACJ,QAAQ,EACR,aAAa,EACb,UAAU,EACV,YAAY,EACZ,UAAU,EACV,YAAY,EACZ,eAAe,EACf,eAAe,EACf,OAAO,EACP,UAAU,EACV,mBAAmB,EACnB,2BAA2B,EAC3B,kBAAkB,EAClB,WAAW,EACX,cAAc,EACd,cAAc,EACd,cAAc,EACd,kBAAkB,GACnB,MAAM,wBAAwB,CAAC;AAChC,YAAY,EACV,YAAY,EACZ,aAAa,EACb,qBAAqB,EACrB,wBAAwB,EACxB,cAAc,EACd,gBAAgB,EAChB,YAAY,GACb,MAAM,wBAAwB,CAAC;AAChC,OAAO,EACL,IAAI,EACJ,IAAI,EACJ,SAAS,EACT,SAAS,EACT,MAAM,EACN,MAAM,EACN,OAAO,EACP,MAAM,EACN,YAAY,EACZ,UAAU,EACV,UAAU,EACV,GAAG,EACH,GAAG,EACH,SAAS,EACT,gBAAgB,EAChB,gBAAgB,EAChB,iBAAiB,EACjB,SAAS,EACT,IAAI,EACJ,uBAAuB,EACvB,kBAAkB,EAClB,gBAAgB,EAChB,oBAAoB,EACpB,uBAAuB,EACvB,mBAAmB,EACnB,QAAQ,EACR,WAAW,EACX,aAAa,EACb,eAAe,EACf,4BAA4B,EAC5B,UAAU,GACX,MAAM,uBAAuB,CAAC;AAC/B,YAAY,EACV,sBAAsB,EACtB,mBAAmB,EACnB,qBAAqB,EACrB,iBAAiB,EACjB,mBAAmB,GACpB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AACtE,YAAY,EAAE,UAAU,EAAE,SAAS,EAAE,OAAO,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAC9F,OAAO,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC"}

package/dist/index.js

@@ -6,7 +6,7 @@
  * import { Vector, Stack, Queue, List, sort, binarySearch, clamp } from 'typescript-dsa-stl';
  */
 export { Vector, Stack, Queue, Deque, List, ListNode, PriorityQueue, OrderedMap, UnorderedMap, OrderedSet, UnorderedSet, OrderedMultiSet, OrderedMultiMap, addEdge, deleteEdge, createAdjacencyList, createWeightedAdjacencyList, GeneralSegmentTree, SegmentTree, SegmentTreeSum, SegmentTreeMin, SegmentTreeMax, LazySegmentTreeSum, } from './collections/index.js';
-export { sort, find, findIndex, transform, filter, reduce, reverse, unique, binarySearch, lowerBound, upperBound, min, max, partition, DisjointSetUnion, KnuthMorrisPratt, StringRollingHash, RabinKarp, RABIN_KARP_DEFAULT_MODS, breadthFirstSearch, depthFirstSearch, topologicalSortStack, topologicalSortIndegree, connectedComponents, dijkstra, reconstructPath, kruskalMST, } from './algorithms/index.js';
+export { sort, find, findIndex, transform, filter, reduce, reverse, unique, binarySearch, lowerBound, upperBound, min, max, partition, DisjointSetUnion, KnuthMorrisPratt, StringRollingHash, RabinKarp, Trie, RABIN_KARP_DEFAULT_MODS, breadthFirstSearch, depthFirstSearch, topologicalSortStack, topologicalSortIndegree, connectedComponents, dijkstra, bellmanFord, floydWarshall, reconstructPath, reconstructFloydWarshallPath, kruskalMST, } from './algorithms/index.js';
 export { clamp, range, noop, identity, swap } from './utils/index.js';
 export { toArray } from './types/index.js';
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EACL,MAAM,EACN,KAAK,EACL,KAAK,EACL,KAAK,EACL,IAAI,EACJ,QAAQ,EACR,aAAa,EACb,UAAU,EACV,YAAY,EACZ,UAAU,EACV,YAAY,EACZ,eAAe,EACf,eAAe,EACf,OAAO,EACP,UAAU,EACV,mBAAmB,EACnB,2BAA2B,EAC3B,kBAAkB,EAClB,WAAW,EACX,cAAc,EACd,cAAc,EACd,cAAc,EACd,kBAAkB,GACnB,MAAM,wBAAwB,CAAC;AAUhC,OAAO,EACL,IAAI,EACJ,IAAI,EACJ,SAAS,EACT,SAAS,EACT,MAAM,EACN,MAAM,EACN,OAAO,EACP,MAAM,EACN,YAAY,EACZ,UAAU,EACV,UAAU,EACV,GAAG,EACH,GAAG,EACH,SAAS,EACT,gBAAgB,EAChB,gBAAgB,EAChB,iBAAiB,EACjB,SAAS,EACT,uBAAuB,EACvB,kBAAkB,EAClB,gBAAgB,EAChB,oBAAoB,EACpB,uBAAuB,EACvB,mBAAmB,EACnB,QAAQ,EACR,eAAe,EACf,UAAU,GACX,MAAM,uBAAuB,CAAC;AAM/B,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AAEtE,OAAO,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EACL,MAAM,EACN,KAAK,EACL,KAAK,EACL,KAAK,EACL,IAAI,EACJ,QAAQ,EACR,aAAa,EACb,UAAU,EACV,YAAY,EACZ,UAAU,EACV,YAAY,EACZ,eAAe,EACf,eAAe,EACf,OAAO,EACP,UAAU,EACV,mBAAmB,EACnB,2BAA2B,EAC3B,kBAAkB,EAClB,WAAW,EACX,cAAc,EACd,cAAc,EACd,cAAc,EACd,kBAAkB,GACnB,MAAM,wBAAwB,CAAC;AAUhC,OAAO,EACL,IAAI,EACJ,IAAI,EACJ,SAAS,EACT,SAAS,EACT,MAAM,EACN,MAAM,EACN,OAAO,EACP,MAAM,EACN,YAAY,EACZ,UAAU,EACV,UAAU,EACV,GAAG,EACH,GAAG,EACH,SAAS,EACT,gBAAgB,EAChB,gBAAgB,EAChB,iBAAiB,EACjB,SAAS,EACT,IAAI,EACJ,uBAAuB,EACvB,kBAAkB,EAClB,gBAAgB,EAChB,oBAAoB,EACpB,uBAAuB,EACvB,mBAAmB,EACnB,QAAQ,EACR,WAAW,EACX,aAAa,EACb,eAAe,EACf,4BAA4B,EAC5B,UAAU,GACX,MAAM,uBAAuB,CAAC;AAQ/B,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AAEtE,OAAO,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "typescript-dsa-stl",
-  "version": "2.8.0",
+  "version": "3.0.0",
   "description": "STL-style data structures and algorithms for TypeScript: Vector, Stack, Queue, Deque (double-ended queue), List, PriorityQueue, Map, Set, sort, binarySearch, graph utilities. Use like C++ STL.",
   "type": "module",
   "main": "dist/index.js",