improve bellman_ford

64json · 64json · commit 8b5ab741622d · 2016-06-04T00:23:31.000+09:00
diff --git a/algorithm/graph_search/bellman_ford/shortest_path/code.js b/algorithm/graph_search/bellman_ford/shortest_path/code.js
@@ -1,57 +1,55 @@
 function BELLMAN_FORD(src, dest) {
-    var weights = new Array(G.length);
+  var weights = new Array(G.length), i, j;
 
-    for (var i = 0; i < G.length; i++) {
-        weights [i] = MAX_VALUE;
-        tracer._weight(i, weights[i]);
-    }
-    weights [src] = 0;
-    tracer._weight(src, 0);
-
-    logger._print('Initializing weights to: [' + weights + ']');
-    logger._print('');
+  for (i = 0; i < G.length; i++) {
+    weights[i] = MAX_VALUE;
+    tracer._weight(i, weights[i]);
+  }
+  weights[src] = 0;
+  tracer._weight(src, 0);
 
-    //begin BF algorithm execution
-    i = G.length - 1;
-    while (i--) {
-        logger._print('Iteration: ' + (G.length - i - 1));
-        logger._print('------------------------------------------------------------------');
+  logger._print('Initializing weights to: [' + weights + ']');
+  logger._print('');
 
-        for (var currentNode = 0; currentNode < G.length; currentNode++) {
-            for (var currentNodeNeighbor = 0; currentNodeNeighbor <= G.length; currentNodeNeighbor++) {
-                if (G [currentNode] [currentNodeNeighbor]) {	//proceed to relax Edges only if a particular weight != 0 (0 represents no edge)
-                    logger._print('Exploring edge from ' + currentNode + ' to ' + currentNodeNeighbor + ', weight = ' + G [currentNode] [currentNodeNeighbor]);
+  //begin BF algorithm execution
+  var k = G.length;
+  while (k--) {
+    logger._print('Iteration: ' + (G.length - k));
+    logger._print('------------------------------------------------------------------');
 
-                    if (weights [currentNodeNeighbor] > (weights [currentNode] + G [currentNode] [currentNodeNeighbor])) {
-                        weights [currentNodeNeighbor] = weights [currentNode] + G [currentNode] [currentNodeNeighbor];
-                        logger._print('weights [' + currentNodeNeighbor + '] = weights [' + currentNode + '] + ' + G [currentNode] [currentNodeNeighbor]);
-                    }
-                    tracer._visit(currentNodeNeighbor, currentNode, weights [currentNodeNeighbor])._wait();
-                    tracer._leave(currentNodeNeighbor, currentNode)._wait();
-                }
-            }
+    for (i = 0; i < G.length; i++) {
+      for (j = 0; j < G.length; j++) {
+        if (G[i][j]) {	//proceed to relax Edges only if a particular weight != 0 (0 represents no edge)
+          if (weights[j] > (weights[i] + G[i][j])) {
+            weights[j] = weights[i] + G[i][j];
+            logger._print('weights[' + j + '] = weights[' + i + '] + ' + G[i][j]);
+          }
+          tracer._visit(j, i, weights[j])._wait();
+          tracer._leave(j, i)._wait();
         }
-
-        logger._print('updated weights: [' + weights + ']');
-        logger._print('');
+      }
     }
 
-    //check for cycle
-    logger._print('checking for cycle');
-    for (currentNode = 0; currentNode < G.length; currentNode++) {
-        for (currentNodeNeighbor = 0; currentNodeNeighbor <= G.length; currentNodeNeighbor++) {
-            if (G [currentNode] [currentNodeNeighbor]) {
-                if (weights [currentNodeNeighbor] > (weights [currentNode] + G [currentNode] [currentNodeNeighbor])) {
-                    logger._print('A cycle was detected: weights [' + currentNodeNeighbor + '] > weights [' + currentNode + '] + ' + G [currentNode] [currentNodeNeighbor]);
-                    return (MAX_VALUE);
-                }
-            }
+    logger._print('updated weights: [' + weights.join(', ') + ']');
+    logger._print('');
+  }
+
+  //check for cycle
+  logger._print('checking for cycle');
+  for (i = 0; i < G.length; i++) {
+    for (j = 0; j < G.length; j++) {
+      if (G[i][j]) {
+        if (weights[j] > (weights[i] + G[i][j])) {
+          logger._print('A cycle was detected: weights[' + j + '] > weights[' + i + '] + ' + G[i][j]);
+          return (MAX_VALUE);
         }
+      }
     }
+  }
 
-    logger._print('No cycles detected. Final weights for the source ' + src + ' are: [' + weights + ']');
+  logger._print('No cycles detected. Final weights for the source ' + src + ' are: [' + weights + ']');
 
-    return weights [dest];
+  return weights[dest];
 }
 
 var src = Math.random() * G.length | 0, dest;
@@ -64,7 +62,7 @@ var minWeight;
  */
 
 do {
-    dest = Math.random() * G.length | 0;
+  dest = Math.random() * G.length | 0;
 }
 while (src === dest);
 
@@ -73,7 +71,7 @@ logger._print('finding the shortest path from ' + src + ' to ' + dest);
 minWeight = BELLMAN_FORD(src, dest);
 
 if (minWeight === MAX_VALUE) {
-    logger._print('there is no path from ' + src + ' to ' + dest);
+  logger._print('there is no path from ' + src + ' to ' + dest);
 } else {
-    logger._print('the shortest path from ' + src + ' to ' + dest + ' is ' + minWeight);
+  logger._print('the shortest path from ' + src + ' to ' + dest + ' is ' + minWeight);
 }
diff --git a/algorithm/graph_search/bellman_ford/shortest_path/data.js b/algorithm/graph_search/bellman_ford/shortest_path/data.js
@@ -1,11 +1,5 @@
 var tracer = new WeightedDirectedGraphTracer();
 var logger = new LogTracer();
 tracer.attach(logger);
-var G = [
-    [0, -1, 4, 0, 0],
-    [0, 0, 3, 2, 2],
-    [0, 0, 0, 0, 0],
-    [0, 1, 5, 0, 0],
-    [0, 0, 0, -3, 0]
-];
+var G = WeightedDirectedGraph.random(5, .5, -2, 5);
 tracer._setData(G);
