Add Dijkstra's algorithm as a problem (#115)

Author: spring1843

README.md

@@ -114,6 +114,7 @@ Welcome to **Data Structures and Algorithms in Go**! 🎉 This project is design
         * [Employee Headcount](./graph/employee_headcount_test.go)
         * [Remove Invalid Parentheses](./graph/remove_invalid_parentheses_test.go)
         * [Cheapest Flights](./graph/cheapest_flights_test.go)
+        * [Dijkstra's Algorithm](./graph/dijkstra_test.go)
         * [Word Ladder](./graph/word_ladder_test.go)
         * [Network Delay Time](./graph/network_delay_time_test.go)
         * [Number of Islands](./graph/number_of_islands_test.go)

graph/README.md

@@ -5,11 +5,11 @@ A graph is a collection of vertices connected through directed or undirected edg
 ```ASCII
 [Figure 1] Graph Examples - Numbers, arrows, and numbers in brackets represent vertices, edges, and edge weights.
 
-     5		3     5	  3              6   	       1 - Is it a DAG?
+     5		3     5	  3              5   	       1 - Is it a DAG?
   ↗  ↑  ↖     ↗   ↘    ↖   ↘	      (4)  ↖ (1)	 2- Is it a connected graph?
  2 → 3 ← 4   2     4    4 ← 2      2 ─────→ 4        A 1 1
   ↖  ↑  ↗     ↖   ↙        ↗   (1) ↑ (2)   ↗ (1)     B 0 1
-     1		1         1        1 ──→ 5	     C 1 0
+     1		1         1        1 ──→ 3	     C 1 0
 						     D 1 1
     (A)	       (B)	 (C)  	      (D)
 ```
@@ -255,58 +255,7 @@ Discovery of a back edge in a DFS algorithm indicates a cyclic graph.
 
 ### Dijkstra's Algorithm
 
-A [greedy](../greedy) algorithm that uses BFS-like ideas and a minimum [heap](../heap) to solve single-source shortest path problems in edge-weighted directed graphs like (D) in _Figure 1_.
-
- ```Go
-package graph_test
-
-import "container/heap"
-
-type (
-    dijkstraVertex struct {
-        val int
-        distance int
-        discovered bool
-        edges map[]*dijkstraVertex
-    }
-    verticesHeap []*dijkstraVertex
-)
-
-func dijkstra(graph []*timedVertex) {
-    h := new(pointsHeap)
-	for _, vertex := range graph {
-		heap.Push(h, vertex)
-    }
-
-    s := make(map[*Vertex]struct{})
-    for h.Len() != 0 {
-        u := h.Pop().(*Vertex)
-        u.discovered = true
-
-        for _, v := range u.Edges {
-            if v.discovered {
-                continue
-            }
-
-            if v.distance + cvw < w.distance {
-                w.distance
-            }
-        }
-    }
-}
-
-func (p verticesHeap) Len() int            { return len(p) }
-func (p verticesHeap) Less(i, j int) bool  { return p[i].distance < p[j].distance }
-func (p verticesHeap) Swap(i, j int)       { p[i], p[j] = p[j], p[i] }
-func (p *verticesHeap) Push(x interface{}) { *p = append(*p, x.(*Vertex)) }
-
-func (p *pointsHeap) Pop() interface{} {
-	old := *p
-	tmp := old[len(old)-1]
-	*p = old[0 : len(old)-1]
-	return tmp
-}
-```
+A [greedy](../greedy) algorithm that uses BFS-like ideas and a minimum [heap](../heap) to solve single-source shortest path problems in edge-weighted directed graphs like finding the shortest path between 1 and 5 in graph (D) in _Figure 1_. The [Dijkstra's Algorithm](./dijkstra_test.go) rehearsal shows an implementation of it.
 
 ## Complexity
 
@@ -326,6 +275,7 @@ Graph algorithms find extensive usage in addressing real-world challenges, inclu
 * [Employee Headcount](./employee_headcount_test.go), [Solution](./employee_headcount.go)
 * [Remove Invalid Parentheses](./remove_invalid_parentheses_test.go), [Solution](./remove_invalid_parentheses.go)
 * [Cheapest Flights](./cheapest_flights_test.go), [Solution](./cheapest_flights.go)
+* [Dijkstra's Algorithm](./dijkstra_test.go), [Solution](./dijkstra.go)
 * [Word Ladder](./word_ladder_test.go), [Solution](./word_ladder.go)
 * [Network Delay Time](./network_delay_time_test.go), [Solution](./network_delay_time.go)
 * [Number of Islands](./number_of_islands_test.go), [Solution](./number_of_islands.go)

graph/dijkstra.go

@@ -0,0 +1,61 @@
+package graph
+
+import (
+	"container/heap"
+	"math"
+)
+
+type (
+	dijkstraVertex struct {
+		val        int
+		distance   int
+		discovered bool
+		edges      []*weightedEdge
+	}
+	weightedEdge struct {
+		edge   *dijkstraVertex
+		weight int
+	}
+	verticesHeap []*dijkstraVertex
+)
+
+// Dijkstra solves the problem in O(ElogV) time and O(V) space.
+func Dijkstra(graph []*dijkstraVertex, source *dijkstraVertex) {
+	for _, vertex := range graph {
+		vertex.distance = math.MaxInt
+		vertex.discovered = false
+	}
+
+	source.distance = 0
+
+	minHeap := new(verticesHeap)
+	heap.Push(minHeap, source)
+
+	for minHeap.Len() != 0 {
+		u := heap.Pop(minHeap).(*dijkstraVertex)
+		u.discovered = true
+
+		for _, edge := range u.edges {
+			v := edge.edge
+			if v.discovered {
+				continue
+			}
+
+			if u.distance+edge.weight < v.distance {
+				v.distance = u.distance + edge.weight
+				heap.Push(minHeap, v)
+			}
+		}
+	}
+}
+
+func (p verticesHeap) Len() int            { return len(p) }
+func (p verticesHeap) Less(i, j int) bool  { return p[i].distance < p[j].distance }
+func (p verticesHeap) Swap(i, j int)       { p[i], p[j] = p[j], p[i] }
+func (p *verticesHeap) Push(x interface{}) { *p = append(*p, x.(*dijkstraVertex)) }
+func (p *verticesHeap) Pop() interface{} {
+	old := *p
+	tmp := old[len(old)-1]
+	*p = old[0 : len(old)-1]
+	return tmp
+}

graph/dijkstra_test.go

@@ -0,0 +1,102 @@
+package graph
+
+import (
+	"testing"
+)
+
+type dijkstraTestCase struct {
+	graph     []*dijkstraVertex
+	distances []int
+}
+
+/*
+TestDijkstra tests solution(s) with the following signature and problem description:
+
+	dijkstraVertex struct {
+		val        int
+		distance   int
+		discovered bool
+		edges      []*weightedEdge
+	}
+	weightedEdge struct {
+		edge   *dijkstraVertex
+		weight int
+	}
+	func Dijkstra(graph []*dijkstraVertex, source *dijkstraVertex)
+
+Implement Dijkstra's algorithm. Given a single sourced edge weighted graph, find the
+shortest path from the source of the graph to every node and set it to the distance
+field of the node.
+
+			     5
+		     (4)  ↖ (1)
+			2 ─────→ 4
+	    (1) ↑ (2) ↗ (1)
+		    1 ──→ 3
+
+For the above graph, the shortest paths for each node are {0, 1, 3, 5, 8}.
+*/
+func TestDijkstra(t *testing.T) {
+	tests := []*dijkstraTestCase{
+		{
+			graph:     newGraph(2),
+			distances: []int{0, 10},
+		},
+		{
+			graph:     newGraph(5),
+			distances: []int{0, 1, 3, 5, 8},
+		},
+		{
+			graph:     newGraph(4),
+			distances: []int{0, 5, 3, 10},
+		},
+		{
+			graph:     newGraph(3),
+			distances: []int{0, 3, 5},
+		},
+		{
+			graph:     newGraph(6),
+			distances: []int{0, 1, 3, 4, 6, 10},
+		},
+	}
+	addEdges(tests)
+
+	for i, test := range tests {
+		Dijkstra(test.graph, test.graph[0])
+		for j, v := range test.graph {
+			if v.distance != test.distances[j] {
+				t.Errorf("Test Case %d, Vertex %d distance: got %d, expected %d", i, v.val, v.distance, test.distances[j])
+			}
+		}
+	}
+}
+
+func newGraph(edges int) []*dijkstraVertex {
+	graph := make([]*dijkstraVertex, edges)
+	for i := 0; i < edges; i++ {
+		graph[i] = &dijkstraVertex{val: i}
+	}
+	return graph
+}
+
+func addEdges(tests []*dijkstraTestCase) {
+	tests[0].graph[0].edges = []*weightedEdge{{edge: tests[0].graph[1], weight: 10}}
+
+	tests[1].graph[0].edges = []*weightedEdge{{edge: tests[1].graph[1], weight: 1}, {edge: tests[1].graph[2], weight: 3}}
+	tests[1].graph[1].edges = []*weightedEdge{{edge: tests[1].graph[2], weight: 2}, {edge: tests[1].graph[3], weight: 4}}
+	tests[1].graph[2].edges = []*weightedEdge{{edge: tests[1].graph[3], weight: 3}, {edge: tests[1].graph[4], weight: 5}}
+	tests[1].graph[3].edges = []*weightedEdge{{edge: tests[1].graph[4], weight: 5}}
+
+	tests[2].graph[0].edges = []*weightedEdge{{edge: tests[2].graph[1], weight: 5}, {edge: tests[2].graph[2], weight: 3}}
+	tests[2].graph[1].edges = []*weightedEdge{{edge: tests[2].graph[2], weight: 2}, {edge: tests[2].graph[3], weight: 6}}
+	tests[2].graph[2].edges = []*weightedEdge{{edge: tests[2].graph[3], weight: 7}}
+
+	tests[3].graph[0].edges = []*weightedEdge{{edge: tests[3].graph[1], weight: 3}, {edge: tests[3].graph[2], weight: 5}}
+	tests[3].graph[1].edges = []*weightedEdge{{edge: tests[3].graph[2], weight: 2}}
+
+	tests[4].graph[0].edges = []*weightedEdge{{edge: tests[4].graph[1], weight: 1}, {edge: tests[4].graph[2], weight: 4}}
+	tests[4].graph[1].edges = []*weightedEdge{{edge: tests[4].graph[2], weight: 2}, {edge: tests[4].graph[3], weight: 5}}
+	tests[4].graph[2].edges = []*weightedEdge{{edge: tests[4].graph[3], weight: 1}, {edge: tests[4].graph[4], weight: 3}}
+	tests[4].graph[3].edges = []*weightedEdge{{edge: tests[4].graph[4], weight: 2}, {edge: tests[4].graph[1], weight: 1}}
+	tests[4].graph[4].edges = []*weightedEdge{{edge: tests[4].graph[5], weight: 4}}
+}

graph/is_dag_test.go

@@ -5,6 +5,10 @@ import "testing"
 /*
 TestIsDAG tests solution(s) with the following signature and problem description:
 
+	Vertex struct {
+			Val int
+			Edges []*Vertex
+	}
 	func IsDAG(graph []*Vertex) bool
 
 Given a directed graph determine if it's a DAG or not. A directed acyclic graph (DAG)

graph/iterative_traversal_test.go

@@ -8,6 +8,10 @@ import (
 /*
 TestIterativeTraversal tests solution(s) with the following signature and problem description:
 
+	Vertex struct {
+			Val int
+			Edges []*Vertex
+	}
 	func IterativeTraversal(graph []*Vertex) ([]int, []int)
 
 Implement BFS and DFS on a graph without using recursion, and return the value of each vertex

graph/topological_sort_test.go

@@ -15,6 +15,11 @@ var readmeGraphs = map[string][][]int{
 /*
 TestTopologicalSort tests solution(s) with the following signature and problem description:
 
+	type VertexWithIngress struct {
+		Val any
+		Edges []*VertexWithIngress
+		Ingress int
+	}
 	func TopologicalSort(graph []*VertexWithIngress) ([]int, error)
 
 In a DAG the topological order returns elements such that if there's a path from v(i) to