Add Dijkstra algorithm

Author: ivmarkp

Min_Spanning_Tree/prim_list.cc

@@ -17,7 +17,6 @@ class graph {
     		adj[v].push_back(make_pair(u, wt));
     	}
     	void prims(int s);
-    	void print_mst();
 };
 
 void graph::prims(int s) {
@@ -31,12 +30,14 @@ void graph::prims(int s) {
 	// intialised as INT_MAX.
 	vector<int> weight(nv, INT_MAX);
 	// Another vector to store the parent of vertices.
-	vector<int> parent(nv, -1);
+	vector<int> parent(nv);
 	// A vector to keep track of vertices included in MST.
 	vector<bool> mst(nv, false);
 
 	// Set weight of source vertex as zero.
 	weight[s] = 0;
+	// Set the parent of source vertex as -1.
+	parent[s] = -1;
 
 	// Insert source vertex in the heap.
 	heap.push(make_pair(weight[s], s));
@@ -64,6 +65,8 @@ void graph::prims(int s) {
 			}
 		}
 	}
+
+	// Print the edges of MST.
 	for (int i = 1; i < nv; i++)
 		cout << parent[i] << " -> " << i << endl;
 	cout << endl;

Shortest_Path/dijkstra_list.cc

@@ -0,0 +1,83 @@
+/**
+ * Djikstra's shortest path algorithm for adjacency list representation
+ * of undirected, connected and weighted graphs.
+ */
+#include <bits/stdc++.h>
+using namespace std;
+
+class Graph {
+	int v;
+	vector<vector<pair<int, int>>> adj;
+	public:
+		Graph(int nv) : v(nv), adj(nv) {}
+		void addEdge(int u, int v, int wt) {
+			adj[u].push_back(make_pair(v, wt));
+			adj[v].push_back(make_pair(u, wt));
+		}
+		void djikstra(int s);
+};
+
+void Graph::djikstra(int s) {
+	priority_queue<pair<int, int>, vector<pair<int, int>>,
+				   greater<pair<int, int>>> heap;
+
+	vector<int> dist(v, INT_MAX);
+	vector<int> parent(v);
+
+	dist[s] = 0;
+	parent[s] = -1;
+
+	heap.push(make_pair(s, dist[s]));
+
+	while (!heap.empty()) {
+		int u = heap.top().first;
+		heap.pop();
+
+		for (auto it = adj[u].begin(); it != adj[u].end(); ++it) {
+			int v = (*it).first;
+			int dist_v = (*it).second;
+
+			// Update distance of v from source if there's
+			// a shorter path to v via u.
+			if (dist[v] > dist[u] + dist_v) {
+				dist[v] = dist[u] + dist_v;
+				// Update parent of v as u.
+				parent[v] = u;
+				// Push v and its updated distance in min heap.
+				heap.push(make_pair(v, dist[v]));
+			}
+		}
+	}
+
+	// Print the shortest path edges
+	for (int i = 1; i < v; i++)
+		cout << parent[i] << " -- " << i << endl;
+}
+
+int main() {
+
+	Graph g(9);
+
+	g.addEdge(0, 1, 4);
+    g.addEdge(0, 7, 8);
+    g.addEdge(1, 2, 8);
+    g.addEdge(1, 7, 11);
+    g.addEdge(2, 3, 7);
+    g.addEdge(2, 8, 2);
+    g.addEdge(2, 5, 4);
+    g.addEdge(3, 4, 9);
+    g.addEdge(3, 5, 14);
+    g.addEdge(4, 5, 10);
+    g.addEdge(5, 6, 2);
+    g.addEdge(6, 7, 1);
+    g.addEdge(6, 8, 6);
+    g.addEdge(7, 8, 7);
+
+	int source;
+	cin >> source;
+
+	g.djikstra(source);
+
+	return 0;
+}
+// Time complexity : O(E * Log V))

Shortest_Path/dijkstra_matrix.cc

@@ -0,0 +1,69 @@
+/**
+ * Djikstra's shortest path algorithm for adjacency matrix representation
+ * of undirected, connected and weighted graphs.
+ */
+#include <bits/stdc++.h>
+using namespace std;
+
+int minDist(vector<bool>& spt, vector<int>& dist, int v) {
+	int min = INT_MAX, index = 0;
+
+	for (int i = 0; i < v; i++) {
+		if (spt[i] == false && dist[i] < min) {
+			min = dist[i];
+			index = i;
+		}
+	}
+
+	return index;
+}
+
+void djikstra(vector<vector<int>>& g, int v, int s) {
+
+	vector<bool> spt_set(v, false);
+	vector<int> dist(v, INT_MAX);
+	vector<int> parent(v);
+
+	dist[s] = 0;
+	parent[s] = -1;
+
+	for (int i = 0; i < v; i++) {
+
+		int u = minDist(spt_set, dist, v);
+		spt_set[u] = true;
+
+		for (int j = 0; j < v; j++) {
+			if (spt_set[j] == false && g[u][j] != 0
+									&& dist[u] + g[u][j] < dist[j]) {
+				dist[j] = dist[u] + g[u][j];
+				parent[j] = u;
+			}
+		}
+	}
+
+	// Print the shortest path edges.
+	for (int i = 1; i < v; i++)
+		// Starting from i = 1 because parent[0] = -1
+		cout << parent[i] << " -- " << i << endl;
+}
+
+int main() {
+	int nv;
+	cin >> nv;
+
+	// A square matrix of size nv to represent the graph.
+	vector<vector<int>> graph(nv, vector<int>(nv));
+
+	for (int i = 0; i < nv; i++)
+		for (int j = 0; j < nv; j++)
+			cin >> graph[i][j];
+
+	int source;
+	cin >> source;
+
+	djikstra(graph, nv, source);
+
+	return 0;
+}
+// Time Complexity: O(V^2). It can be reduced to O(E * logV) by trading
+// space for a binary heap.