add depth first paths

Author: shellfly

cmd/depth-first-paths/main.go

@@ -0,0 +1,63 @@
+/*
+   Execution:  go run cmd/depth-first-paths/main.go G s
+
+   Data files:   https://algs4.cs.princeton.edu/41graph/tinyCG.txt
+                 https://algs4.cs.princeton.edu/41graph/tinyG.txt
+                 https://algs4.cs.princeton.edu/41graph/mediumG.txt
+                 https://algs4.cs.princeton.edu/41graph/largeG.txt
+
+   Run depth first search on an undirected graph.
+   Runs in O(E + V) time.
+
+   %  go run cmd/graph/main.go tinyCG.txt
+   6 8
+   0: 2 1 5
+   1: 0 2
+   2: 0 1 3 4
+   3: 5 4 2
+   4: 3 2
+   5: 3 0
+
+   % go run cmd/depth-first-paths/main.go tinyCG.txt 0
+   0 to 0:  0
+   0 to 1:  0-2-1
+   0 to 2:  0-2
+   0 to 3:  0-2-3
+   0 to 4:  0-2-3-4
+   0 to 5:  0-2-3-5
+
+*/
+
+package main
+
+import (
+	"fmt"
+	"os"
+	"strconv"
+
+	"github.com/shellfly/algo"
+	"github.com/shellfly/algo/stdin"
+)
+
+func main() {
+	graph := algo.NewGraph(stdin.NewIn(os.Args[1]))
+	s, _ := strconv.Atoi(os.Args[2])
+	p := algo.NewDepthFirstPaths(graph, s)
+
+	for v := 0; v < graph.V(); v++ {
+		if p.HasPathTo(v) {
+			fmt.Printf("%d to %d: ", s, v)
+			for _, x := range p.PathTo(v) {
+				if x == s {
+					fmt.Print(x)
+				} else {
+					fmt.Printf("-%d", x)
+				}
+			}
+			fmt.Println()
+		} else {
+			fmt.Printf("%d and %d: not connected\n", s, v)
+		}
+	}
+
+}

depth_first_paths.go

@@ -0,0 +1,48 @@
+package algo
+
+// DepthFirstPaths ...
+type DepthFirstPaths struct {
+	marked []bool
+	edgeTo []int
+	s      int
+}
+
+// NewDepthFirstPaths ...
+func NewDepthFirstPaths(g *Graph, s int) *DepthFirstPaths {
+	dfs := &DepthFirstPaths{marked: make([]bool, g.V()), edgeTo: make([]int, g.V()), s: s}
+	dfs.Dfs(g, s)
+	return dfs
+}
+
+// Dfs ...
+func (s *DepthFirstPaths) Dfs(g *Graph, v int) {
+	s.marked[v] = true
+	for _, w := range g.Adj(v) {
+		if !s.marked[w] {
+			s.edgeTo[w] = v
+			s.Dfs(g, w)
+		}
+	}
+}
+
+// HasPathTo ...
+func (s *DepthFirstPaths) HasPathTo(v int) bool {
+	return s.marked[v]
+}
+
+// PathTo ...
+func (s *DepthFirstPaths) PathTo(v int) []int {
+	if !s.HasPathTo(v) {
+		return nil
+	}
+	path := NewStack()
+	for x := v; x != s.s; x = s.edgeTo[x] {
+		path.Push(x)
+	}
+	path.Push(s.s)
+	vertexes := []int{}
+	for _, x := range path.Slice() {
+		vertexes = append(vertexes, x.(int))
+	}
+	return vertexes
+}

graph.go

@@ -21,7 +21,6 @@ func NewGraph(in *stdin.In) *Graph {
 	}
 	g := &Graph{v: v, e: 0, adj: adj}
 	e := in.ReadInt()
-	fmt.Println(v, e)
 	for i := 0; i < e; i++ {
 		v, w := in.ReadInt(), in.ReadInt()
 		g.AddEdge(v, w)

stack.go

@@ -38,3 +38,11 @@ func (s *Stack) Pop() (item interface{}) {
 func (s Stack) Size() int {
 	return s.n
 }
+
+// Slice ...
+func (s Stack) Slice() (items []interface{}) {
+	for !s.IsEmpty() {
+		items = append(items, s.Pop())
+	}
+	return
+}