topological sort shortest paths

Author: chen0040

README.md

@@ -425,6 +425,47 @@ 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) + '=========');
+    }
+}
+```
+
+### Find the shortest paths using Topological Sort Shortest Paths
+
+The sample code below show how to obtain the shortest paths from a starting point 0 on a weighted directed acylic graph using Topological Sort:
+
+```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.TopologicalSortShortestPaths(g, 0);
+
 for(var v = 1; v < g.V; ++v){
     if(bf.hasPathTo(v)){
         var path = bf.pathTo(v);

package.json

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

src/jsgraphs.js

@@ -448,6 +448,19 @@ var jsgraphs = jsgraphs || {};
         this.adjList[v].push(e);
     };
 
+    WeightedDiGraph.prototype.toDiGraph = function() {
+        var g = new jss.DiGraph(this.V);
+        for(var v = 0; v < this.V; ++v) {
+            var adj_v = this.adjList[v];
+            for (var i =0; i < adj_v.length; ++i) {
+                var e = adj_v[i];
+                var w = e.other(v);
+                g.addEdge(v, w);
+            }
+        }
+        return g;
+    };
+    
     jss.WeightedDiGraph = WeightedDiGraph;
 
     var DepthFirstSearch = function(G, s) {
@@ -904,6 +917,69 @@ var jsgraphs = jsgraphs || {};
     };
 
     jss.BellmanFord = BellmanFord;
+    
+    var TopologicalSortShortestPaths = 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;
+        
+        var order = new jss.TopologicalSort(G.toDiGraph()).order();
+        
+        
+        for(var j = 0; j < order.length; ++j){
+            var v = order[j];
+            var adj_v = G.adj(v);
+            for(var i = 0; i < adj_v.length; ++i) {
+                var e = adj_v[i];
+                this.relax(e);
+            }
+        }
+        
+        
+    };
+    
+    TopologicalSortShortestPaths.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;
+        }
+    };
+    
+    TopologicalSortShortestPaths.prototype.hasPathTo = function(v) {
+        return this.marked[v];  
+    };
+
+    
+    TopologicalSortShortestPaths.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();
+    };
+    
+    TopologicalSortShortestPaths.prototype.distanceTo = function(v) {
+        return this.cost[v];  
+    };
+    
+    jss.TopologicalSortShortestPaths = TopologicalSortShortestPaths;
 
 })(jsgraphs);
 

test/topoloical-sort-shortest-paths-spec.js

@@ -0,0 +1,47 @@
+var expect = require('chai').expect;
+var jsgraphs = require('../src/jsgraphs');
+
+describe('Topological Sort Shortest Path', function(){
+   it('should get shortest path from Weigthed Directed Acyclic 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 ts = new jsgraphs.TopologicalSortShortestPaths(g, 0);
+       
+        for(var v = 1; v < g.V; ++v){
+            if(ts.hasPathTo(v)){
+                var path = ts.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: '  + ts.distanceTo(v) + '=========');
+            }
+        }
+   });
+});