Merge pull request #105 from RamSamarthPaliwal/main

Added Johnson’s algorithm & Minimum Spanning Tree in CPP folder ( with code.cpp + beautiful readme.md ) !!! (click me & see comment for more info)

CPP/Johnson’s Algorithm/README.md

@@ -0,0 +1,39 @@
+# Algorithm johnsonAlgorithm(cost)
+
+###### Input − The cost matrix of given Graph.
+###### Output − Matrix to for shortest path between any vertex to any vertex.
+
+### Algorithm :-
+
+```
+Begin
+   Create another matrix ‘A’ same as cost matrix, if there is no edge between ith row and jth column, put infinity at A[i,j].
+   for k := 1 to n, do
+      for i := 1 to n, do
+         for j := 1 to n, do
+            A[i, j] = minimum of A[i, j] and (A[i, k] + A[k, j])
+         done
+      done
+   done
+   display the current A matrix
+End
+Example
+```
+
+I added .cpp file example, use below Output to test it
+
+###### Output
+```
+Enter no of vertices: 3
+Enter no of edges: 5
+Enter the EDGE Costs:
+1 2 8
+2 1 12
+1 3 22
+3 1 6
+2 3 4
+Resultant adj matrix
+0 8 12
+10 0 4
+6 14 0
+```

CPP/Johnson’s Algorithm/johnson.cpp

@@ -0,0 +1,37 @@
+#include<iostream>
+#define INF 9999
+using namespace std;
+int min(int a, int b);
+int cost[10][10], adj[10][10];
+inline int min(int a, int b){
+   return (a<b)?a:b;
+}
+main() {
+   int vert, edge, i, j, k, c;
+   cout << "Enter no of vertices: ";
+   cin >> vert;
+   cout << "Enter no of edges: ";
+   cin >> edge;
+   cout << "Enter the EDGE Costs:\n";
+   for (k = 1; k <= edge; k++) { //take the input and store it into adj and cost matrix
+      cin >> i >> j >> c;
+      adj[i][j] = cost[i][j] = c;
+   }
+   for (i = 1; i <= vert; i++)
+      for (j = 1; j <= vert; j++) {
+         if (adj[i][j] == 0 && i != j)
+            adj[i][j] = INF; //if there is no edge, put infinity
+      }
+   for (k = 1; k <= vert; k++)
+      for (i = 1; i <= vert; i++)
+         for (j = 1; j <= vert; j++)
+            adj[i][j] = min(adj[i][j], adj[i][k] + adj[k][j]); //find minimum path from i to j through k
+   cout << "Resultant adj matrix\n";
+   for (i = 1; i <= vert; i++) {
+      for (j = 1; j <= vert; j++) {
+            if (adj[i][j] != INF)
+               cout << adj[i][j] << " ";
+      }
+      cout << "\n";
+   }
+}

CPP/Minimum Spanning Tree Algorithm/Kruskal/README.md

@@ -0,0 +1,22 @@
+# Kruskal’s Minimum Spanning Tree Algorithm
+
+The algorithm is a Greedy Algorithm. The Greedy Choice is to pick the smallest weight edge that does not cause a cycle in the MST constructed so far.
+
+### Algorithm:-
+```
+1. Sort all the edges in non-decreasing order of their weight. 
+2. Pick the smallest edge. Check if it forms a cycle with the spanning tree formed so far. If cycle is not formed, include this edge. Else, discard it. 
+3. Repeat step#2 until there are (V-1) edges in the spanning tree.
+```
+
+I added code.cpp file, below is the output of file
+
+###### Output
+
+```
+Following are the edges in the constructed MST
+2 -- 3 == 4
+0 -- 3 == 5
+0 -- 1 == 10
+Minimum Cost Spanning Tree: 19
+```

CPP/Minimum Spanning Tree Algorithm/Kruskal/code.cpp

@@ -0,0 +1,200 @@
+// C++ program for Kruskal's algorithm
+// to find Minimum Spanning Tree of a
+// given connected, undirected and weighted
+// graph
+#include <bits/stdc++.h>
+using namespace std;
+
+// a structure to represent a 
+// weighted edge in graph
+class Edge {
+public:
+	int src, dest, weight;
+};
+
+// a structure to represent a connected, 
+// undirected and weighted graph
+class Graph {
+public:
+
+	// V-> Number of vertices, E-> Number of edges
+	int V, E;
+
+	// graph is represented as an array of edges.
+	// Since the graph is undirected, the edge
+	// from src to dest is also edge from dest
+	// to src. Both are counted as 1 edge here.
+	Edge* edge;
+};
+
+// Creates a graph with V vertices and E edges
+Graph* createGraph(int V, int E)
+{
+	Graph* graph = new Graph;
+	graph->V = V;
+	graph->E = E;
+
+	graph->edge = new Edge[E];
+
+	return graph;
+}
+
+// A structure to represent a subset for union-find
+class subset {
+public:
+	int parent;
+	int rank;
+};
+
+// A utility function to find set of an element i
+// (uses path compression technique)
+int find(subset subsets[], int i)
+{
+	// find root and make root as parent of i
+	// (path compression)
+	if (subsets[i].parent != i)
+		subsets[i].parent
+			= find(subsets, subsets[i].parent);
+
+	return subsets[i].parent;
+}
+
+// A function that does union of two sets of x and y
+// (uses union by rank)
+void Union(subset subsets[], int x, int y)
+{
+	int xroot = find(subsets, x);
+	int yroot = find(subsets, y);
+
+	// Attach smaller rank tree under root of high
+	// rank tree (Union by Rank)
+	if (subsets[xroot].rank < subsets[yroot].rank)
+		subsets[xroot].parent = yroot;
+	else if (subsets[xroot].rank > subsets[yroot].rank)
+		subsets[yroot].parent = xroot;
+
+	// If ranks are same, then make one as root and
+	// increment its rank by one
+	else {
+		subsets[yroot].parent = xroot;
+		subsets[xroot].rank++;
+	}
+}
+
+// Compare two edges according to their weights.
+// Used in qsort() for sorting an array of edges
+int myComp(const void* a, const void* b)
+{
+	Edge* a1 = (Edge*)a;
+	Edge* b1 = (Edge*)b;
+	return a1->weight > b1->weight;
+}
+
+// The main function to construct MST using Kruskal's
+// algorithm
+void KruskalMST(Graph* graph)
+{
+	int V = graph->V;
+	Edge result[V]; // Tnis will store the resultant MST
+	int e = 0; // An index variable, used for result[]
+	int i = 0; // An index variable, used for sorted edges
+
+	// Step 1: Sort all the edges in non-decreasing
+	// order of their weight. If we are not allowed to
+	// change the given graph, we can create a copy of
+	// array of edges
+	qsort(graph->edge, graph->E, sizeof(graph->edge[0]),
+		myComp);
+
+	// Allocate memory for creating V ssubsets
+	subset* subsets = new subset[(V * sizeof(subset))];
+
+	// Create V subsets with single elements
+	for (int v = 0; v < V; ++v) 
+	{
+		subsets[v].parent = v;
+		subsets[v].rank = 0;
+	}
+
+	// Number of edges to be taken is equal to V-1
+	while (e < V - 1 && i < graph->E) 
+	{
+		// Step 2: Pick the smallest edge. And increment
+		// the index for next iteration
+		Edge next_edge = graph->edge[i++];
+
+		int x = find(subsets, next_edge.src);
+		int y = find(subsets, next_edge.dest);
+
+		// If including this edge does't cause cycle,
+		// include it in result and increment the index
+		// of result for next edge
+		if (x != y) {
+			result[e++] = next_edge;
+			Union(subsets, x, y);
+		}
+		// Else discard the next_edge
+	}
+
+	// print the contents of result[] to display the
+	// built MST
+	cout << "Following are the edges in the constructed "
+			"MST\n";
+	int minimumCost = 0;
+	for (i = 0; i < e; ++i) 
+	{
+		cout << result[i].src << " -- " << result[i].dest
+			<< " == " << result[i].weight << endl;
+		minimumCost = minimumCost + result[i].weight;
+	}
+	// return;
+	cout << "Minimum Cost Spanning Tree: " << minimumCost
+		<< endl;
+}
+
+// Driver code
+int main()
+{
+	/* Let us create following weighted graph
+			10
+		0--------1
+		| \ |
+	6| 5\ |15
+		| \ |
+		2--------3
+			4 */
+	int V = 4; // Number of vertices in graph
+	int E = 5; // Number of edges in graph
+	Graph* graph = createGraph(V, E);
+
+	// add edge 0-1
+	graph->edge[0].src = 0;
+	graph->edge[0].dest = 1;
+	graph->edge[0].weight = 10;
+
+	// add edge 0-2
+	graph->edge[1].src = 0;
+	graph->edge[1].dest = 2;
+	graph->edge[1].weight = 6;
+
+	// add edge 0-3
+	graph->edge[2].src = 0;
+	graph->edge[2].dest = 3;
+	graph->edge[2].weight = 5;
+
+	// add edge 1-3
+	graph->edge[3].src = 1;
+	graph->edge[3].dest = 3;
+	graph->edge[3].weight = 15;
+
+	// add edge 2-3
+	graph->edge[4].src = 2;
+	graph->edge[4].dest = 3;
+	graph->edge[4].weight = 4;
+
+
+	// Function call
+	KruskalMST(graph);
+
+	return 0;
+}

CPP/Minimum Spanning Tree Algorithm/README.md

@@ -0,0 +1,3 @@
+## (In this folder, I have added Krushal's Minimum Spanning Tree Algo)
+# What is Minimum Spanning Tree? 
+Given a connected and undirected graph, a spanning tree of that graph is a subgraph that is a tree and connects all the vertices together. A single graph can have many different spanning trees. A minimum spanning tree (MST) or minimum weight spanning tree for a weighted, connected and undirected graph is a spanning tree with weight less than or equal to the weight of every other spanning tree. The weight of a spanning tree is the sum of weights given to each edge of the spanning tree.