Merge branch 'gh-pages' of https://github.com/parkjs814/AlgorithmVisualizer into gh-pages

Author: 64json

LICENSE

@@ -4,10 +4,10 @@ Copyright (c) 2016 Jason Park
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
+in the Software without restriction, including without limiting the rights
 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
+furnished to do so, subjected to the following conditions:
 
 The above copyright notice and this permission notice shall be included in
 all copies or substantial portions of the Software.

algorithm/category.json

@@ -7,7 +7,8 @@
       "dijkstra": "Dijkstra",
       "bellman_ford": "Bellman-Ford",
       "floyd_warshall": "Floyd-Warshall",
-      "topological_sort": "Topological-Sort"
+      "topological_sort": "Topological-Sort",
+      "bridges": "Find-Bridges"
     }
   },
   "mst": {

algorithm/etc/dp/desc.json

@@ -12,6 +12,7 @@
     "sliding_window": "Finding the largest sum of three contiguous number",
     "max_sum_path": "Finding the maximum sum in a path from (0, 0) to (N-1, M-1) when can only move to right or down",
     "longest_increasing_subsequence": "Find the length of the longest subsequence of a given sequence such that all elements of the subsequence are sorted in increasing order",
-    "max_subarray": "Find the sum of the maximum Subarray in the given Array"
+    "max_subarray": "Find the sum of the maximum Subarray in the given Array",
+    "knapsack_problem": "Given a set of items, each with a weight and a value, determine the number of each item to include in a collection so that the total weight is less than or equal to a given limit and the total value is as large as possible."
   }
 }

algorithm/etc/dp/knapsack_problem/code.js

@@ -0,0 +1,46 @@
+
+for ( var i = 0; i <= N; i++ ) {
+	for( var j = 0; j <= W; j++ ) {
+		if( i === 0 || j === 0 ) { 
+			/*
+			If we have no items or maximum weight we can take in collection is 0 
+			then the total weight in our collection is 0
+			*/
+			DP[i][0] = 0;
+			tracer._notify( i, j, DP[i][j])._wait();
+			tracer._denotify( i, j);
+		} else if ( wt[i-1] <= j ) { // take the current item in our collection
+
+			dataViewer1._select(i-1)._wait();
+			dataViewer2._select(i-1)._wait();
+			tracer._select( i-1, j)._wait();
+
+			var A = val[i - 1] + DP[i - 1][j - wt[i - 1]];
+			var B = DP[i - 1][j];
+			/*
+			find the maximum of these two values
+			and take which gives us a greater weight
+			 */
+			if (A > B) {
+				DP[i][j] = A;
+				tracer._notify( i, j, DP[i][j])._wait();
+			} else {
+				DP[i][j] = B;
+				tracer._notify( i, j, DP[i][j])._wait();
+			}
+
+			tracer._deselect( i-1, j);
+			tracer._denotify( i, j);
+			dataViewer2._deselect(i-1);
+			dataViewer1._deselect(i-1);
+
+		} else { // leave the current item from our collection 
+
+			DP[i][j] = DP[i - 1][j];
+			tracer._notify( i, j, DP[i][j])._wait();
+			tracer._denotify( i, j);
+		}
+	}
+}
+
+logger._print(' Best value we can achieve is ' + DP[N][W]);

algorithm/etc/dp/knapsack_problem/data.js

@@ -0,0 +1,17 @@
+var val = [1,4,5,7]; // The value of all available items
+var wt = [1,3,4,5];  // The weights of available items
+var W = 7;           // The maximum weight we can carry in our collection
+var N = val.length;
+var DP = new Array(N+1);
+
+for (var i = 0; i < N + 1; i++) {
+    DP[i] = new Array(W+1);
+    for (var j = 0; j < W + 1; j++) {
+        DP[i][j] = 0;
+    }
+}
+
+var tracer = new Array2DTracer()._setData(DP);
+var dataViewer1 = new Array1DTracer()._setData(val);
+var dataViewer2 = new Array1DTracer()._setData(wt);
+var logger = new LogTracer();

algorithm/graph_search/bridges/desc.json

@@ -0,0 +1,16 @@
+{
+  "Bridges": "An edge in an undirected connected graph is a bridge iff removing it disconnects the graph. A naive solution to finding bridges in a graph is to:<br />1.Delete an edge E<br />2.Perform DFS Exploration to check is Graph is connected<br />3.Restore Edge E. E is a bridge only if DFS explore determines that the graph is disconnected without E",
+  "Applications": [
+    "Find vulnerabilities in Graphs and Electrical Circuits"
+  ],
+  "Complexity": {
+    "time": "worst O(|E|.(|V|+|E|))",
+    "space": "worst O(|V|.|E|)"
+  },
+  "References": [
+    "<a href='https://en.wikipedia.org/wiki/Bridge_(graph_theory)'>Wikipedia</a>"
+  ],
+  "files": {
+    "naive": "Find all the bridges in an Undirected Graph"
+  }
+}

algorithm/graph_search/bridges/naive/code.js

@@ -0,0 +1,66 @@
+//Depth First Search Exploration Algorithm to test connectedness of the Graph (see Graph Algorithms/DFS/exploration), without the tracer & logger commands
+function DFSExplore (graph, source) {
+	var stack = [ [source, null] ], visited = {};
+	var node, prev, i, temp;
+
+	while (stack.length > 0) {
+		temp = stack.pop ();
+		node = temp [0];
+		prev = temp [1];
+
+		if (!visited [node]) {
+			visited [node] = true;
+			//logger._print (node);
+
+			/*
+			if (prev !== undefined && graph [node] [prev]) { tracer._visit (node, prev)._wait (); console.log ('tracer ' + prev + ', ' + node); }
+			else { tracer._visit (node)._wait (); console.log ('tracer ' + node); }
+			*/
+
+			for (i = 0; i < graph.length; i++) {
+				if (graph [node] [i]) {
+					stack.push ([i, node]);
+				}
+			}
+		}
+	}
+
+	return visited;
+}
+
+function findBridges (graph) {
+	var tempGraph, bridges = [], visited;
+
+	for (var i = 0; i < graph.length; i++) {
+		for (var j = 0; j < graph.length; j++) {
+			if (graph [i] [j]) {	//check if an edge exists
+				logger._print ('Deleting edge ' + i + '->' + j + ' and calling DFSExplore ()');
+				tracer._visit (j, i)._wait ();
+				tracer._leave (j, i)._wait ();
+
+				tempGraph = JSON.parse (JSON.stringify (graph));
+				tempGraph [i] [j] = 0;
+				tempGraph [j] [i] = 0;
+				visited = DFSExplore (tempGraph, 0);
+
+				if (Object.keys (visited).length === graph.length) {
+					logger._print ('Graph is CONNECTED. Edge is NOT a bridge');
+				}
+				else {
+					logger._print ('Graph is DISCONNECTED. Edge IS a bridge');
+					bridges.push ([i,j]);
+				}
+			}
+		}
+	}
+
+	return bridges;
+}
+
+var bridges = findBridges (G);
+
+logger._print ('The bridges are: ');
+for (var i in bridges) {
+	logger._print (bridges [i] [0] + ' to ' + bridges [i] [1]);
+}
+logger._print ('NOTE: A bridge is both ways, i.e., from A to B and from B to A, because this is an Undirected Graph');

algorithm/graph_search/bridges/naive/data.js

@@ -0,0 +1,12 @@
+var tracer = new UndirectedGraphTracer ();
+var logger = new LogTracer ();
+var G = [
+	[0,1,0,0,0,0],
+	[1,0,0,1,1,0],
+	[0,0,0,1,0,0],
+	[0,1,1,0,1,1],
+	[0,1,0,1,0,0],
+	[0,0,0,1,0,0]
+];
+
+tracer._setData (G);

algorithm/graph_search/dfs/desc.json

@@ -24,6 +24,7 @@
     "tree": "Searching a tree",
     "all_paths": "Going through all possible paths without making any circuit",
     "weighted_graph": "DFS of Weighted Graph",
-    "shortest_path": "Finding the shortest path"
+    "shortest_path": "Finding the shortest path",
+    "exploration": "Explore an undirected graph to see if it is connected"
   }
 }

algorithm/graph_search/dfs/exploration/code.js

@@ -0,0 +1,35 @@
+function DFSExplore (graph, source) {
+	var stack = [ [source, null] ], visited = {};
+	var node, prev, i, temp;
+
+	while (stack.length > 0) {
+		temp = stack.pop ();
+		node = temp [0];
+		prev = temp [1];
+
+		if (!visited [node]) {
+			visited [node] = true;
+			logger._print (node);
+
+			if (prev !== undefined && graph [node] [prev]) { tracer._visit (node, prev)._wait (); console.log ('tracer ' + prev + ', ' + node); }
+			else { tracer._visit (node)._wait (); console.log ('tracer ' + node); }
+
+			for (i = 0; i < graph.length; i++) {
+				if (graph [node] [i]) {
+					stack.push ([i, node]);
+				}
+			}
+		}
+	}
+
+	return visited;
+}
+
+
+var visited = DFSExplore (G, 0);
+if (G.length === Object.keys (visited).length) {
+	logger._print ('The Graph is CONNECTED');
+}
+else {
+	logger._print ('The Graph is NOT CONNECTED');
+}