ocaml: phase 5.1 dijkstra.ml baseline (5-node SSSP, dist(0,4) = 7)

Array-based O(n^2) Dijkstra on a small directed weighted graph:

  edges = [|
    [(1, 4); (2, 1)];   (* 0 -> 1 (w=4), 2 (w=1) *)
    [(3, 1)];           (* 1 -> 3 (w=1)         *)
    [(1, 2); (3, 5)];   (* 2 -> 1 (w=2), 3 (w=5) *)
    [(4, 3)];           (* 3 -> 4 (w=3)         *)
    []                  (* 4 sink              *)
  |]

Optimal path 0->2->1->3->4 has weight 1+2+1+3 = 7.

Tests: array-of-list-of-int-pair literal, List.iter with tuple
destructuring closure, in-place dist mutation, nested for + ref.

141 baseline programs total.

lib/ocaml/baseline/dijkstra.ml

@@ -0,0 +1,37 @@
+let n = 5
+
+let edges = [|
+  [(1, 4); (2, 1)];
+  [(3, 1)];
+  [(1, 2); (3, 5)];
+  [(4, 3)];
+  []
+|]
+
+let dijkstra src =
+  let dist = Array.make n 1000000 in
+  dist.(src) <- 0;
+  let visited = Array.make n false in
+  for _ = 0 to n - 1 do
+    let u = ref (-1) in
+    let best = ref 1000000 in
+    for v = 0 to n - 1 do
+      if (not visited.(v)) && dist.(v) < !best then begin
+        best := dist.(v);
+        u := v
+      end
+    done;
+    if !u >= 0 then begin
+      visited.(!u) <- true;
+      List.iter (fun (v, w) ->
+        if dist.(!u) + w < dist.(v) then
+          dist.(v) <- dist.(!u) + w
+      ) edges.(!u)
+    end
+  done;
+  dist
+
+;;
+
+let d = dijkstra 0 in
+d.(4)

lib/ocaml/baseline/expected.json

@@ -25,6 +25,7 @@
   "coin_change.ml": 6,
   "count_change.ml": 406,
   "csv.ml": 10,
+  "dijkstra.ml": 7,
   "exception_handle.ml": 4,
   "exception_user.ml": 26,
   "euler1.ml": 233168,

plans/ocaml-on-sx.md

@@ -407,6 +407,15 @@ _Newest first._
   binary search tree (`type 'a tree = Leaf | Node of 'a * 'a tree *
   'a tree`) with insert + in-order traversal. Tests parametric ADT,
   recursive match, List.append, List.fold_left.
+- 2026-05-10 Phase 5.1 — dijkstra.ml baseline (single-source shortest
+  path on a 5-node weighted graph, dist 0→4 = 7). O(n²) array-based
+  Dijkstra: at each step, scan unvisited vertices for the minimum
+  tentative distance, relax outgoing edges. Adjacency stored as
+  `(int * int) list array` literal with int-pair tuples for
+  destination + weight. The optimal path 0→2→1→3→4 has weight
+  1+2+1+3=7. Tests array of lists of pairs, List.iter with
+  destructuring closure, in-place dist mutation. 141 baseline
+  programs total.
 - 2026-05-10 Phase 5.1 — kmp.ml baseline (KMP string search, count
   occurrences of "abab" in "abababcabababcababcc" = 5). Two-phase
   classic: build failure table in O(m), then linear scan in O(n).