add acyclic and bellman ford sp

Author: shellfly

README.md

@@ -75,6 +75,9 @@ To test each algorithm(data structure), instead of running the file directly, yo
   * Shortest Paths
     * [EdgeWeightedDigraph](edge_weighted_digraph.go)
     * [DijkstraSP](dijkstra_sp.go)
+    * [AcyclicSP](acyclic_sp.go)
+    * [BellmanFordSP](bellman_ford_sp.go)
+
 
 * 5 STRING
 

acyclic_sp.go

@@ -0,0 +1,56 @@
+package algo
+
+// AcyclicSP ...
+type AcyclicSP struct {
+	distTo []float32
+	edgeTo []*DirectedEdge
+}
+
+// NewAcyclicSP ...
+func NewAcyclicSP(g *EdgeWeightedDigraph, s int) *AcyclicSP {
+	edgeTo := make([]*DirectedEdge, g.V())
+	distTo := make([]float32, g.V())
+	for v := 0; v < g.V(); v++ {
+		distTo[v] = PositiveInfinity
+	}
+	distTo[s] = 0.0
+	a := &AcyclicSP{distTo, edgeTo}
+	top := NewEWDTopological(g)
+	for _, e := range top.Order() {
+		a.relax(e)
+	}
+	return a
+
+}
+
+func (a *AcyclicSP) relax(e *DirectedEdge) {
+	v := e.From()
+	w := e.To()
+	if a.distTo[w] > a.distTo[v]+e.Weight() {
+		a.distTo[w] = a.distTo[v] + e.Weight()
+		a.edgeTo[w] = e
+	}
+}
+
+// DistTo ...
+func (a *AcyclicSP) DistTo(v int) float32 {
+	return a.distTo[v]
+}
+
+// HasPathTo ...
+func (a *AcyclicSP) HasPathTo(v int) bool {
+	return a.distTo[v] < PositiveInfinity
+}
+
+// PathTo ...
+func (a *AcyclicSP) PathTo(v int) (edges []*DirectedEdge) {
+	if !a.HasPathTo(v) {
+		return nil
+	}
+
+	for e := a.edgeTo[v]; e != nil; e = a.edgeTo[e.From()] {
+		// stack
+		edges = append([]*DirectedEdge{e}, edges...)
+	}
+	return
+}

bellman_ford_sp.go

@@ -0,0 +1,92 @@
+package algo
+
+// BellmanFordSP ...
+type BellmanFordSP struct {
+	distTo []float32
+	edgeTo []*DirectedEdge
+	onQ    []bool
+	queue  *Queue
+	cost   int
+	cycle  []*DirectedEdge
+}
+
+// NewBellmanFordSP ...
+func NewBellmanFordSP(g *EdgeWeightedDigraph, s int) *BellmanFordSP {
+	edgeTo := make([]*DirectedEdge, g.V())
+	distTo := make([]float32, g.V())
+	onQ := make([]bool, g.V())
+	queue := NewQueue()
+	for v := 0; v < g.V(); v++ {
+		distTo[v] = PositiveInfinity
+	}
+	distTo[s] = 0.0
+	queue.Enqueue(s)
+	onQ[s] = true
+	b := &BellmanFordSP{distTo, edgeTo, onQ, queue, 0, nil}
+	for !queue.IsEmpty() && !b.hasNegativeCycle() {
+		v := queue.Dequeue().(int)
+		b.onQ[v] = false
+		b.relax(g, v)
+	}
+	return b
+}
+
+func (b *BellmanFordSP) relax(g *EdgeWeightedDigraph, v int) {
+	for _, e := range g.Adj(v) {
+		w := e.To()
+		if b.distTo[w] > b.distTo[v]+e.Weight() {
+			b.distTo[w] = b.distTo[v] + e.Weight()
+			b.edgeTo[w] = e
+			if !b.onQ[w] {
+				b.queue.Enqueue(w)
+				b.onQ[w] = true
+			}
+		}
+		b.cost++
+		if b.cost%g.V() == 0 {
+			b.findNegativeCycle()
+			if b.hasNegativeCycle() {
+				return // found a negative cycle
+			}
+		}
+	}
+}
+
+func (b *BellmanFordSP) findNegativeCycle() {
+	V := len(b.edgeTo)
+	spt := NewEdgeWeightedDigraphV(V)
+	for v := 0; v < V; v++ {
+		if b.edgeTo[v] != nil {
+			spt.AddEdge(b.edgeTo[v])
+		}
+	}
+
+	finder := NewEdgeWeightedDirectedCycle(spt)
+	b.cycle = finder.Cycle()
+}
+func (b *BellmanFordSP) hasNegativeCycle() bool {
+	return b.cycle != nil
+}
+
+// DistTo ...
+func (b *BellmanFordSP) DistTo(v int) float32 {
+	return b.distTo[v]
+}
+
+// HasPathTo ...
+func (b *BellmanFordSP) HasPathTo(v int) bool {
+	return b.distTo[v] < PositiveInfinity
+}
+
+// PathTo ...
+func (b *BellmanFordSP) PathTo(v int) (edges []*DirectedEdge) {
+	if !b.HasPathTo(v) {
+		return nil
+	}
+
+	for e := b.edgeTo[v]; e != nil; e = b.edgeTo[e.From()] {
+		// stack
+		edges = append([]*DirectedEdge{e}, edges...)
+	}
+	return
+}

cmd/edge-weighted-digraph/main.go

@@ -8,15 +8,15 @@
  *  Parallel edges and self-loops are permitted.
  *
  *  % 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
+ * 8 vertices, 15 edges
+ * 0:  0->2 0.26000  0->4 0.38000
+ * 1:  1->3 0.29000
+ * 2:  2->7 0.34000
+ * 3:  3->6 0.52000
+ * 4:  4->7 0.37000  4->5 0.35000
+ * 5:  5->1 0.32000  5->7 0.28000  5->4 0.35000
+ * 6:  6->4 0.93000  6->0 0.58000  6->2 0.40000
+ * 7:  7->3 0.39000  7->5 0.28000
  *
  ******************************************************************************/
 
@@ -31,6 +31,6 @@ import (
 )
 
 func main() {
-	graph := algo.NewEdgeWeightedGraph(stdin.NewIn(os.Args[1]))
+	graph := algo.NewEdgeWeightedDigraph(stdin.NewIn(os.Args[1]))
 	fmt.Println(graph)
 }

digraph.go

@@ -6,6 +6,12 @@ import (
 	"github.com/shellfly/algo/stdin"
 )
 
+// DigraphInterface ...
+type DigraphInterface interface {
+	V() int
+	Adj() []*DirectedEdge
+}
+
 // Digraph ...
 type Digraph struct {
 	v, e int

edge_weighted_directed_cycle.go

@@ -0,0 +1,58 @@
+package algo
+
+// EdgeWeightedDirectedCycle for EdgeWeightedDigrapy
+// Note: this is file is just placeholder, see detail algorithm in directed_cycle.go
+type EdgeWeightedDirectedCycle struct {
+	marked  []bool
+	edgeTo  []int
+	cycle   []*DirectedEdge
+	onStack []bool
+}
+
+// NewEdgeWeightedDirectedCycle ...
+func NewEdgeWeightedDirectedCycle(g *EdgeWeightedDigraph) *EdgeWeightedDirectedCycle {
+	marked := make([]bool, g.V())
+	edgeTo := make([]int, g.V())
+	onStack := make([]bool, g.V())
+	c := &EdgeWeightedDirectedCycle{marked: marked, edgeTo: edgeTo, onStack: onStack}
+	if c.hasSelfLoop(g) {
+		return c
+	}
+	if c.hasParallelEdges(g) {
+		return c
+	}
+
+	for v := 0; v < g.V(); v++ {
+		if !c.marked[v] {
+			c.Dfs(g, -1, v)
+		}
+	}
+	return c
+}
+
+// hasSelfLoop ...
+func (c *EdgeWeightedDirectedCycle) hasSelfLoop(g *EdgeWeightedDigraph) bool {
+
+	return false
+}
+
+// hasParallelEdges ...
+func (c *EdgeWeightedDirectedCycle) hasParallelEdges(g *EdgeWeightedDigraph) bool {
+
+	return false
+}
+
+// Dfs ...
+func (c *EdgeWeightedDirectedCycle) Dfs(g *EdgeWeightedDigraph, u, v int) {
+
+}
+
+// HasCycle ...
+func (c *EdgeWeightedDirectedCycle) HasCycle() bool {
+	return c.cycle != nil
+}
+
+// Cycle ...
+func (c *EdgeWeightedDirectedCycle) Cycle() []*DirectedEdge {
+	return c.cycle
+}

ewd_topological.go

@@ -0,0 +1,17 @@
+package algo
+
+// EWDTopological implements topological order for a edge weighted digraph
+type EWDTopological struct {
+	order []*DirectedEdge
+}
+
+// NewEWDTopological ...
+func NewEWDTopological(g *EdgeWeightedDigraph) *EWDTopological {
+	// See topological.go for detail algorithm
+	return &EWDTopological{}
+}
+
+// Order ...
+func (t *EWDTopological) Order() []*DirectedEdge {
+	return t.order
+}