bellman-ford

Author: chen0040

README.md

@@ -357,7 +357,7 @@ for(var i=0; i < mst.length; ++i) {
 }
 ```
 
-### find the shortest paths using Dijkstra on weighted directed graph
+### Find the shortest paths using Dijkstra
 
 The sample code below show how to obtain the shortest paths from a starting point 0 on a weighted directed graph using Dijkstra:
 
@@ -381,13 +381,6 @@ g.addEdge(new jsgraphs.Edge(5, 6, 13.0));
 g.addEdge(new jsgraphs.Edge(7, 5, 6.0));
 g.addEdge(new jsgraphs.Edge(7, 2, 7.0));  
 
-expect(g.V).to.equal(8);
-var edgeCount = 0;
-for(var v = 0; v < g.V; ++v){
-    var adj_v = g.adj(v);
-    edgeCount += adj_v.length;
-}
-expect(edgeCount).to.equal(16);
 
 var dijkstra = new jsgraphs.Dijkstra(g, 0);
 
@@ -403,4 +396,45 @@ for(var v = 1; v < g.V; ++v){
         console.log('=====distance: '  + dijkstra.distanceTo(v) + '=========');
     }
 }
+```
+
+### Find the shortest paths using Bellman-Ford
+
+The sample code below show how to obtain the shortest paths from a starting point 0 on a weighted directed graph using Bellman-Ford:
+
+```javascript
+var jsgraphs = require('js-graph-algorithms');
+var g = new jsgraphs.WeightedDiGraph(8);
+g.addEdge(new jsgraphs.Edge(0, 1, 5.0));
+g.addEdge(new jsgraphs.Edge(0, 4, 9.0));
+g.addEdge(new jsgraphs.Edge(0, 7, 8.0));
+g.addEdge(new jsgraphs.Edge(1, 2, 12.0));
+g.addEdge(new jsgraphs.Edge(1, 3, 15.0));
+g.addEdge(new jsgraphs.Edge(1, 7, 4.0));
+g.addEdge(new jsgraphs.Edge(2, 3, 3.0));
+g.addEdge(new jsgraphs.Edge(2, 6, 11.0));
+g.addEdge(new jsgraphs.Edge(3, 6, 9.0));
+g.addEdge(new jsgraphs.Edge(4, 5, 5.0));
+g.addEdge(new jsgraphs.Edge(4, 6, 20.0));
+g.addEdge(new jsgraphs.Edge(4, 7, 5.0));
+g.addEdge(new jsgraphs.Edge(5, 2, 1.0));
+g.addEdge(new jsgraphs.Edge(5, 6, 13.0));
+g.addEdge(new jsgraphs.Edge(7, 5, 6.0));
+g.addEdge(new jsgraphs.Edge(7, 2, 7.0));  
+
+
+var bf = new jsgraphs.BellmanFord(g, 0);
+
+for(var v = 1; v < g.V; ++v){
+    if(bf.hasPathTo(v)){
+        var path = bf.pathTo(v);
+        console.log('=====path from 0 to ' + v + ' start==========');
+        for(var i = 0; i < path.length; ++i) {
+            var e = path[i];
+            console.log(e.from() + ' => ' + e.to() + ': ' + e.weight);
+        }
+        console.log('=====path from 0 to ' + v + ' end==========');
+        console.log('=====distance: '  + bf.distanceTo(v) + '=========');
+    }
+}
 ```

package.json

@@ -1,6 +1,6 @@
 {
   "name": "js-graph-algorithms",
-  "version": "1.0.6",
+  "version": "1.0.7",
   "description": "Package implements data structures and algorithms for processing various types of graphs",
   "author": "Xianshun Chen",
   "contributors": [

src/jsgraphs.js

@@ -844,6 +844,66 @@ var jsgraphs = jsgraphs || {};
 
 
     jss.Dijkstra = Dijkstra;
+    
+    var BellmanFord = function(G, s) {
+        var V = G.V;
+        this.s = s;
+        this.marked = [];
+        this.edgeTo = [];
+        this.cost = [];
+        
+        
+        for(var v =0; v < V; ++v){
+            this.marked.push(false);
+            this.edgeTo.push(null);
+            this.cost.push(Number.MAX_VALUE);
+        }
+        
+        this.cost[s] = 0;
+        this.marked[s] = true;
+        
+        for(var j = 0; j < V; ++j) {
+            for(var v = 0; v < V; ++v){
+                var adj_v = G.adj(v);
+                for(var i = 0; i < adj_v.length; ++i) {
+                    var e = adj_v[i];
+                    this.relax(e);
+                }
+            }
+        }
+        
+    };
+    
+    BellmanFord.prototype.relax = function(e) {
+        
+        var v = e.from();
+        var w = e.to();
+        
+        if(this.cost[w] > this.cost[v] + e.weight) {
+            this.cost[w] = this.cost[v] + e.weight;
+            this.marked[w] = true;
+            this.edgeTo[w] = e;
+        }
+    };
+    
+    BellmanFord.prototype.hasPathTo = function(v) {
+        return this.marked[v];  
+    };
+
+    
+    BellmanFord.prototype.pathTo = function(v) {
+        var path = new jss.Stack();
+        for(var x = v; x != this.s; x = this.edgeTo[x].from()) {
+            path.push(this.edgeTo[x]);
+        }  
+        return path.toArray();
+    };
+    
+    BellmanFord.prototype.distanceTo = function(v) {
+        return this.cost[v];  
+    };
+    
+    jss.BellmanFord = BellmanFord;
 
 })(jsgraphs);
 

test/bellman-ford-spec.js

@@ -0,0 +1,47 @@
+var expect = require('chai').expect;
+var jsgraphs = require('../src/jsgraphs');
+
+describe('Bellman Ford', function(){
+   it('should get shortest path from Weigthed Directed Graph', function(){
+        var g = new jsgraphs.WeightedDiGraph(8);
+        g.addEdge(new jsgraphs.Edge(0, 1, 5.0));
+        g.addEdge(new jsgraphs.Edge(0, 4, 9.0));
+        g.addEdge(new jsgraphs.Edge(0, 7, 8.0));
+        g.addEdge(new jsgraphs.Edge(1, 2, 12.0));
+        g.addEdge(new jsgraphs.Edge(1, 3, 15.0));
+        g.addEdge(new jsgraphs.Edge(1, 7, 4.0));
+        g.addEdge(new jsgraphs.Edge(2, 3, 3.0));
+        g.addEdge(new jsgraphs.Edge(2, 6, 11.0));
+        g.addEdge(new jsgraphs.Edge(3, 6, 9.0));
+        g.addEdge(new jsgraphs.Edge(4, 5, 5.0));
+        g.addEdge(new jsgraphs.Edge(4, 6, 20.0));
+        g.addEdge(new jsgraphs.Edge(4, 7, 5.0));
+        g.addEdge(new jsgraphs.Edge(5, 2, 1.0));
+        g.addEdge(new jsgraphs.Edge(5, 6, 13.0));
+        g.addEdge(new jsgraphs.Edge(7, 5, 6.0));
+        g.addEdge(new jsgraphs.Edge(7, 2, 7.0));  
+       
+        expect(g.V).to.equal(8);
+        var edgeCount = 0;
+        for(var v = 0; v < g.V; ++v){
+            var adj_v = g.adj(v);
+            edgeCount += adj_v.length;
+        }
+        expect(edgeCount).to.equal(16);
+       
+        var bf = new jsgraphs.BellmanFord(g, 0);
+       
+        for(var v = 1; v < g.V; ++v){
+            if(bf.hasPathTo(v)){
+                var path = bf.pathTo(v);
+                console.log('=====path from 0 to ' + v + ' start==========');
+                for(var i = 0; i < path.length; ++i) {
+                    var e = path[i];
+                    console.log(e.from() + ' => ' + e.to() + ': ' + e.weight);
+                }
+                console.log('=====path from 0 to ' + v + ' end==========');
+                console.log('=====distance: '  + bf.distanceTo(v) + '=========');
+            }
+        }
+   });
+});