perf(dfa): faster predecessor state lookup

Store a reversed copy of DFA state transitions for faster lookup of
predecessor states. That halves the time for part 2 in the AOC
benchmark: 40 seconds to 20 seconds.

Author: gruhn

benchmark/aoc2023-day12.js

@@ -91,7 +91,7 @@ function part2() {
 }
 
 const sol1 = part1() // best time:   992ms
-const sol2 = part2() // best time: 28258ms
+const sol2 = part2() // best time: 20095ms
 
 console.log('Part 1:', sol1.totalCount, `(time: ${Math.ceil(sol1.time)}ms)`)
 console.log('Part 2:', sol2.totalCount, `(time: ${Math.ceil(sol2.time)}ms)`)

src/dfa.ts

@@ -2,6 +2,7 @@ import * as CharSet from "./char-set"
 import * as RE from "./regex"
 import { assert } from "./utils"
 import * as Table from './table'
+import * as Graph from './graph'
 
 export type DFA = Readonly<{
   allStates: Map<number, RE.ExtRegex>
@@ -44,7 +45,7 @@ function regexToDFA(regex: RE.ExtRegex): DFA {
         worklist.push(targetState)
         // console.debug('state count: ', allStates.size)
       } else {
-        Table.setWith(
+        Table.set(
           sourceState.hash,
           knownState.hash,
           charSet,
@@ -70,81 +71,54 @@ function regexToDFA(regex: RE.ExtRegex): DFA {
   }
 }
 
-type RipStateResult = {
-  predecessors: [number, RE.StdRegex][]
-  selfLoop: RE.StdRegex
-  successors: [number, RE.StdRegex][]
-}
-
-function ripState(state: number, transitions: Table.Table<RE.StdRegex>): RipStateResult {
-  const selfLoop = Table.get(state, state, transitions) ?? RE.epsilon
-
-  const successorsMap = transitions.get(state) ?? new Map<number, RE.StdRegex>()
-  // handle self loops separately:
-  successorsMap.delete(state)
-  const successors = [...successorsMap.entries()]
-  transitions.delete(state)
-
-  const predecessors: [number, RE.StdRegex][] = []
-  for (const [source, transitionsFromSource] of transitions) {
-    // handle self loops separately:
-    if (source !== state) {
-      const label = transitionsFromSource.get(state)
-      if (label !== undefined) {
-        predecessors.push([source, label])
-        transitionsFromSource.delete(state)
-      }
-    }
-  }
-
-  return { selfLoop, successors, predecessors }
-}
-
 export function dfaToRegex(dfa: DFA): RE.StdRegex {
-  const transitionsWithRegexLabels = Table.map(dfa.transitions, RE.literal)
+  const graph = Graph.create<RE.StdRegex>()
+  for (const [source, target, charSet] of Table.entries(dfa.transitions)) {
+    Graph.setEdge(source, target, RE.literal(charSet), graph)   
+  }
 
   const newStartState = -1
-  Table.set(
+  Graph.setEdge(
     newStartState,
     dfa.startState,
     RE.epsilon,
-    transitionsWithRegexLabels,
+    graph
   )
 
   const newFinalState = -2
   for (const oldFinalState of dfa.finalStates) {
-    Table.set(
+    Graph.setEdge(
       oldFinalState,
       newFinalState,
       RE.epsilon,
-      transitionsWithRegexLabels,
+      graph
     )
   }
 
   for (const state of dfa.allStates.keys()) {
-    const result = ripState(state, transitionsWithRegexLabels)
+    const result = Graph.ripNode(state, graph)
 
     for (const [pred, predLabel] of result.predecessors) {
       for (const [succ, succLabel] of result.successors) {
         const transitiveLabel = RE.seq([
           predLabel,
-          RE.star(result.selfLoop),
+          RE.star(result.selfLoop ?? RE.epsilon),
           succLabel,
         ])
 
-        Table.setWith(
-          pred,
+        Graph.setEdge(
+          pred, 
           succ,
           transitiveLabel,
-          transitionsWithRegexLabels,
+          graph, 
           RE.union,
         )
       }
     }
   }
 
-  assert(transitionsWithRegexLabels.size === 1)
-  const transitionsFromNewStart = transitionsWithRegexLabels.get(newStartState)
+  assert(graph.successors.size === 1)
+  const transitionsFromNewStart = graph.successors.get(newStartState)
   assert(transitionsFromNewStart !== undefined)
 
   if (transitionsFromNewStart.size === 0) {

src/graph.ts

@@ -0,0 +1,108 @@
+import * as Table from "./table"
+
+/**
+ * Directed graph where nodes are identified by numbers
+ * and edges labels have generic type `A`.
+ * For efficient access to both successors and predecessors of nodes,
+ * two copies of the edges are stored. `predecessors` should always
+ * be the same as `successors`, only that edges are reversed.
+ */
+export type Graph<A> = {
+  successors: Table.Table<A>
+  predecessors: Table.Table<A>
+}
+
+export function create<A>(): Graph<A> {
+  return {
+    predecessors: new Map(),
+    successors: new Map()
+  }
+}
+
+/**
+ * Number of in-going edges at `node` (not counting self-loop).
+ */
+export function inDegree<A>(node: number, graph: Graph<A>): number {
+  const preds = graph.predecessors.get(node) ?? new Map()
+  if (preds.has(node))
+    return preds.size - 1
+  else
+    return preds.size
+}
+
+/**
+ * Number of out-going edges at `node` (not counting self-loop).
+ */
+export function outDegree<A>(node: number, graph: Graph<A>): number {
+  const succs = graph.successors.get(node) ?? new Map()
+  if (succs.has(node))
+    return succs.size - 1
+  else
+    return succs.size
+}
+
+export type RipNodeResult<A> = {
+  predecessors: [number, A][]
+  selfLoop: A | undefined
+  successors: [number, A][]
+}
+
+/**
+ * Removes `node` from `graph` including all in-going and out-going
+ * edges of `node`. Returns the removed edges.
+ */
+export function ripNode<A>(node: number, graph: Graph<A>): RipNodeResult<A> {
+  const selfLoop = Table.get(node, node, graph.successors)
+
+  const successorsMap = graph.successors.get(node) ?? new Map<number, A>()
+  successorsMap.delete(node) // remove self-loop
+  const successors = [...successorsMap.entries()]
+
+  // remove successors from successors Map:
+  graph.successors.delete(node)
+  // remove successors from predecessor Map:
+  for (const [succ,_] of successors) {
+    Table.remove(succ, node, graph.predecessors)
+  }
+
+  const predecessorMap = graph.predecessors.get(node) ?? new Map<number, A>()
+  predecessorMap.delete(node) // remove self-loop
+  const predecessors = [...predecessorMap.entries()]
+
+  // remove predecessors from predecessor Map:
+  graph.predecessors.delete(node)
+  // remove predecessors from successor Map:
+  for (const [pred,_] of predecessors) {
+    Table.remove(pred, node, graph.successors)
+  }
+
+  return { selfLoop, successors, predecessors }
+}
+
+/**
+ * Adds an edge to `graph` from `sourceNode` to `targetNode` with `edgeLabel`.
+ * If there is already an edge between these nodes, `combine` is called to 
+ * to combine the two edge labels.
+ */
+export function setEdge<A>(
+  sourceNode: number,
+  targetNode: number,
+  edgeLabel: A,
+  graph: Graph<A>,
+  combine?: (oldLabel: A, newLabel: A) => A,
+): void {
+  Table.set(
+    sourceNode,
+    targetNode,
+    edgeLabel,
+    graph.successors,
+    combine,
+  )
+  Table.set(
+    targetNode,
+    sourceNode,
+    edgeLabel,
+    graph.predecessors,
+    combine,
+  ) 
+}

src/table.ts

@@ -14,27 +14,16 @@ export function remove<T>(
   return table.get(rowIndex)?.delete(colIndex)
 }
 
-export function set<T>(
-  rowIndex: number,
-  colIndex: number,
-  newValue: T,
-  table: Table<T>,
-): void {
-  return setWith(
-    rowIndex,
-    colIndex,
-    newValue,
-    table,
-    () => { throw new Error('Table.set cell non-empty') } 
-  )
+function crashOnConflict<T>(): T {
+  throw new Error('Table.set cell non-empty')
 }
 
-export function setWith<T>(
+export function set<T>(
   rowIndex: number,
   colIndex: number,
   newValue: T,
   table: Table<T>,
-  combine: (oldValue: T, newValue: T) => T
+  combine: (oldValue: T, newValue: T) => T = crashOnConflict
 ): void {
   let row = table.get(rowIndex)
   if (row === undefined) {
@@ -60,3 +49,19 @@ export function map<A,B>(table: Table<A>, fn: (_: A) => B): Table<B> {
     )
   ) 
 }
+
+export function* entries<A>(table: Table<A>): Generator<[number, number, A]> {
+  for (const [rowIndex, row] of table.entries()) {
+    for (const [colIndex, value] of row.entries()) {
+      yield [rowIndex, colIndex, value]
+    }
+  }
+}
+
+export function fromEntries<A>(items: Iterable<[number, number, A]>): Table<A> {
+  const table: Table<A> = new Map()
+  for (const [rowIndex, colIndex, value] of items) {
+    set(rowIndex, colIndex, value, table)
+  }
+  return table
+}