add Dijkstra SP

Author: shellfly

README.md

@@ -74,6 +74,7 @@ To test each algorithm(data structure), instead of running the file directly, yo
     * [KruskalMST](kruskal_mst.go)
   * Shortest Paths
     * [EdgeWeightedDigraph](edge_weighted_digraph.go)
+    * [DijkstraSP](dijkstra_sp.go)
 
 * 5 STRING
 

cmd/dijkstra-sp/main.go

@@ -0,0 +1,56 @@
+/******************************************************************************
+ *  Execution:    go run cmd/dijkstra-sp/main.go input.txt s
+ *  Data files:   https://algs4.cs.princeton.edu/44sp/tinyEWD.txt
+ *                https://algs4.cs.princeton.edu/44sp/mediumEWD.txt
+ *                https://algs4.cs.princeton.edu/44sp/largeEWD.txt
+ *
+ *  Dijkstra's algorithm. Computes the shortest path tree.
+ *  Assumes all weights are nonnegative.
+ *
+ *  % go run cmd/dijkstra-sp/main.go tinyEWD.txt 0
+ *  0 to 0 (0.00)
+ *  0 to 1 (1.05)  0->4  0.38   4->5  0.35   5->1  0.32
+ *  0 to 2 (0.26)  0->2  0.26
+ *  0 to 3 (0.99)  0->2  0.26   2->7  0.34   7->3  0.39
+ *  0 to 4 (0.38)  0->4  0.38
+ *  0 to 5 (0.73)  0->4  0.38   4->5  0.35
+ *  0 to 6 (1.51)  0->2  0.26   2->7  0.34   7->3  0.39   3->6  0.52
+ *  0 to 7 (0.60)  0->2  0.26   2->7  0.34
+ *
+ *  % go run cmd/dijkstra-sp/main.go mediumEWD.txt 0
+ *  0 to 0 (0.00)
+ *  0 to 1 (0.71)  0->44  0.06   44->93  0.07   ...  107->1  0.07
+ *  0 to 2 (0.65)  0->44  0.06   44->231  0.10  ...  42->2  0.11
+ *  0 to 3 (0.46)  0->97  0.08   97->248  0.09  ...  45->3  0.12
+ *  0 to 4 (0.42)  0->44  0.06   44->93  0.07   ...  77->4  0.11
+ *  ...
+ *
+ ******************************************************************************/
+
+package main
+
+import (
+	"fmt"
+	"os"
+	"strconv"
+
+	"github.com/shellfly/algo"
+	"github.com/shellfly/algo/stdin"
+)
+
+func main() {
+	graph := algo.NewEdgeWeightedDigraph(stdin.NewIn(os.Args[1]))
+	s, _ := strconv.Atoi(os.Args[2])
+	sp := algo.NewDijkstraSP(graph, s)
+	for t := 0; t < graph.V(); t++ {
+		if sp.HasPathTo(t) {
+			fmt.Printf("%d to %d (%.2f)  ", s, t, sp.DistTo(t))
+			for _, e := range sp.PathTo(t) {
+				fmt.Print(e, " ")
+			}
+			fmt.Println()
+		} else {
+			fmt.Printf("%d to %d         no path\n", s, t)
+		}
+	}
+}

cmd/edge-weighted-digraph/main.go

@@ -1,22 +1,22 @@
 /******************************************************************************
- *  Execution:    go run cmd/edge-weighted-graph/main.go filename.txt
+ *  Execution:    go run cmd/edge-weighted-digraph/main.go filename.txt
  *  Data files:   https://algs4.cs.princeton.edu/43mst/tinyEWG.txt
  *                https://algs4.cs.princeton.edu/43mst/mediumEWG.txt
  *                https://algs4.cs.princeton.edu/43mst/largeEWG.txt
  *
  *  An edge-weighted undirected graph, implemented using adjacency lists.
  *  Parallel edges and self-loops are permitted.
  *
- *  % go run cmd/edge-weighted-graph/main.go tinyEWG.txt
- *  8 16
- *  0: 6-0 0.58000  0-2 0.26000  0-4 0.38000  0-7 0.16000
- *  1: 1-3 0.29000  1-2 0.36000  1-7 0.19000  1-5 0.32000
- *  2: 6-2 0.40000  2-7 0.34000  1-2 0.36000  0-2 0.26000  2-3 0.17000
- *  3: 3-6 0.52000  1-3 0.29000  2-3 0.17000
- *  4: 6-4 0.93000  0-4 0.38000  4-7 0.37000  4-5 0.35000
- *  5: 1-5 0.32000  5-7 0.28000  4-5 0.35000
- *  6: 6-4 0.93000  6-0 0.58000  3-6 0.52000  6-2 0.40000
- *  7: 2-7 0.34000  1-7 0.19000  0-7 0.16000  5-7 0.28000  4-7 0.37000
+ *  % go run cmd/edge-weighted-digraph/main.go tinyEWD.txt
+ *  8 vertices, 15 edges
+ *  0:  6-0 0.58000  0-2 0.26000  0-4 0.38000
+ *  1:  1-3 0.29000  5-1 0.32000
+ *  2:  6-2 0.40000  2-7 0.34000  0-2 0.26000
+ *  3:  3-6 0.52000  1-3 0.29000  7-3 0.39000
+ *  4:  6-4 0.93000  0-4 0.38000  4-7 0.37000  5-4 0.35000  4-5 0.35000
+ *  5:  5-1 0.32000  7-5 0.28000  5-7 0.28000  5-4 0.35000  4-5 0.35000
+ *  6:  6-4 0.93000  6-0 0.58000  3-6 0.52000  6-2 0.40000
+ *  7:  2-7 0.34000  7-3 0.39000  7-5 0.28000  5-7 0.28000  4-7 0.37000
  *
  ******************************************************************************/
 

dijkstra_sp.go

@@ -0,0 +1,69 @@
+package algo
+
+// PositiveInfinity is a fake positive infinity value
+const PositiveInfinity = 999999.0
+
+// DijkstraSP ...
+type DijkstraSP struct {
+	distTo []float32
+	edgeTo []*DirectedEdge
+	pq     *IndexMinPQ
+}
+
+// NewDijkstraSP ...
+func NewDijkstraSP(g *EdgeWeightedDigraph, s int) *DijkstraSP {
+	edgeTo := make([]*DirectedEdge, g.V())
+	distTo := make([]float32, g.V())
+	for v := 0; v < g.V(); v++ {
+		distTo[v] = PositiveInfinity
+	}
+	distTo[s] = 0.0
+	pq := NewIndexMinPQ(g.V())
+	d := &DijkstraSP{distTo, edgeTo, pq}
+
+	pq.Insert(s, FloatPQItem(distTo[s]))
+	for !pq.IsEmpty() {
+		d.relax(g, pq.DelMin())
+	}
+
+	return d
+
+}
+
+func (d *DijkstraSP) relax(g *EdgeWeightedDigraph, v int) {
+	for _, e := range g.Adj(v) {
+		w := e.To()
+		if d.distTo[w] > d.distTo[v]+e.Weight() {
+			d.distTo[w] = d.distTo[v] + e.Weight()
+			d.edgeTo[w] = e
+			if d.pq.Contains(w) {
+				d.pq.ChangeKey(w, FloatPQItem(d.distTo[w]))
+			} else {
+				d.pq.Insert(w, FloatPQItem(d.distTo[w]))
+			}
+		}
+	}
+}
+
+// DistTo ...
+func (d *DijkstraSP) DistTo(v int) float32 {
+	return d.distTo[v]
+}
+
+// HasPathTo ...
+func (d *DijkstraSP) HasPathTo(v int) bool {
+	return d.distTo[v] < PositiveInfinity
+}
+
+// PathTo ...
+func (d *DijkstraSP) PathTo(v int) (edges []*DirectedEdge) {
+	if !d.HasPathTo(v) {
+		return nil
+	}
+
+	for e := d.edgeTo[v]; e != nil; e = d.edgeTo[e.From()] {
+		// stack
+		edges = append([]*DirectedEdge{e}, edges...)
+	}
+	return
+}

directed_edge.go

@@ -30,7 +30,7 @@ func (e *DirectedEdge) To() int {
 
 // String ...
 func (e *DirectedEdge) String() string {
-	return fmt.Sprintf("%d-%d %.5f", e.v, e.w, e.weight)
+	return fmt.Sprintf("%d->%d %.5f", e.v, e.w, e.weight)
 }
 
 // CompareTo implements PQItem interface

edge_weighted_digraph.go

@@ -49,7 +49,7 @@ func (g *EdgeWeightedDigraph) E() int {
 
 // AddEdge ...
 func (g *EdgeWeightedDigraph) AddEdge(e *DirectedEdge) {
-	g.adj[e.From()].Add(e.To())
+	g.adj[e.From()].Add(e)
 	g.e++
 }
 

index_min_pq.go

@@ -76,8 +76,8 @@ func (mq *IndexMinPQ) Insert(i int, key PQItem) {
 // ChangeKey ...
 func (mq *IndexMinPQ) ChangeKey(i int, key PQItem) {
 	mq.validateIndex(i)
-	if mq.Contains(i) {
-		panic("Index is alreay in the priority queue")
+	if !mq.Contains(i) {
+		panic("Index is not in the priority queue")
 	}
 
 	mq.keys[i] = key