Day - 76 work

Author: mandliya

README.md

@@ -6,9 +6,9 @@
 
 | Current Status|     Stats     |
 | :------------: | :----------: |
-| Total Problems | 110 |
-| Current Streak | 75 days |
-| Longest Streak | 75 ( August 17, 2015 - October 30, 2015 ) |
+| Total Problems | 111 |
+| Current Streak | 76 days |
+| Longest Streak | 76 ( August 17, 2015 - October 31, 2015 ) |
 
 </center>
 
@@ -165,6 +165,7 @@ Include contains single header implementation of data structures and some algori
 | Breadth First Traversal of a Graph | [bfsDemo.cpp](graph_problems/bfsDemo.cpp) |
 | calculate the shortest distance from the start position (Node S) to all of the other nodes in the graph using Dijkstra algorithm. | [dijkstra-shortest-reach.cpp](graph_problems/dijkstra-shortest-reach.cpp)|
 | Calculate total weight of Minimum Spanning Tree of a given graph ( sum of weights of edges which forms MST) using Prim's algorithm | [primsMST.cpp](graph_problems/primsMST.cpp)|
+| Print Minimum Spanning Tree( MST ) of a given graph using Kruskal's algorithm.| [kruskalMST.cpp](graph_problems/kruskalMST.cpp)|
 
 ###Greedy Problems
 | Problem | Solution |

graph_problems/kruskalMST.cpp

@@ -0,0 +1,139 @@
+/**
+ * Given an undirected weighted connected graph, it is required to find the Really Special SubTree in it.
+ * The Really Special SubTree is defined as a subgraph consisting of all the nodes in the graph and
+ * There is only one exclusive path from a node to every other node.
+ * The subgraph is of minimum overall weight (sum of all edges) among all such subgraphs.
+ * While creating the Really Special SubTree, start of by picking the edge with smallest weight.
+ * If there are edges of equal weight available at an instant, then the edge to be chosen first among them is the
+ * one with minimum value of sum of the following expression :
+ * u + wt + v , where u and v are the node numbers of the corresponding edge and wt is the weight.
+ * Even then if there is a collision, choose any one of them.
+ * While doing the above, ensure that no cycle is formed while picking up edges.
+ */
+
+#include <cmath>
+#include <cstdio>
+#include <vector>
+#include <iostream>
+#include <algorithm>
+using namespace std;
+
+struct Edge {
+    int x;
+    int y;
+    int r;
+    Edge( int a, int b, int c) : x{ a-1 }, y{ b-1 }, r{ c } { }
+};
+
+bool sortComparer( Edge a, Edge b ) {
+    if ( a.r < b.r ) {
+        return true;
+    } else if ( a.r > b.r ) {
+        return false;
+    }
+    return ( a.x + a.y + a.r  <= b.x + b.y + b.r);
+}
+
+class Graph {
+  public:
+    Graph(int N, int M) : V{ N }, E{ M }, edges(E, Edge(0,0,0)) { }
+    void getEdges();
+    void sortEdges();
+    int numberOfVertices() { return V; }
+    int numberOfEdges() { return E; }
+    std::vector<Edge>  kruskalMST();
+  private:
+    int V; //number of vertices
+    int E; //number of Edges
+    std::vector<Edge> edges;
+};
+
+void Graph::getEdges( ) {
+    int x, y, r;
+    for ( int i = 0; i < E; ++i ) {
+        std::cin >> x >> y >> r;
+        edges.push_back(Edge(x, y, r));
+    }
+}
+
+void Graph::sortEdges() {
+    std::sort(edges.begin(), edges.end(), sortComparer);
+}
+
+struct subset {
+  int rank;
+  int parent;
+};
+
+int find( std::vector<subset> & subsets, int i ) {
+    if ( subsets[i].parent != i ) {
+        subsets[i].parent = find(subsets, subsets[i].parent);
+    }
+    return subsets[i].parent;
+}
+
+void union_edges( std::vector<subset> & subsets, int a, int b) {
+    int aroot = find(subsets, a);
+    int broot = find(subsets, b);
+    if ( subsets[aroot].rank < subsets[broot].rank ) {
+        subsets[aroot].parent = broot;
+    } else if ( subsets[aroot].rank > subsets[broot].rank ) {
+        subsets[broot].parent = aroot;
+    } else {
+        subsets[broot].parent = aroot;
+        subsets[broot].rank++;
+    }
+}
+
+std::vector<Edge> Graph::kruskalMST() {
+    sortEdges();
+    std::vector<subset> subsets(numberOfEdges());
+    for ( int i = 0; i < numberOfEdges(); ++i ) {
+        subsets[i].rank = 0;
+        subsets[i].parent = i;
+    }
+    int e = 0;
+    int i = 0;
+	std::vector<Edge> resultMST;
+    while ( e < numberOfVertices() - 1) {
+        Edge next_edge = edges[i++];
+        int a = find( subsets, next_edge.x );
+        int b = find( subsets, next_edge.y );
+        if ( a != b ) {
+			resultMST.push_back(next_edge);
+            union_edges(subsets, a, b);
+            ++e;
+        }
+    }
+    return resultMST;
+}
+
+void printMST(std::vector<Edge> & MST) {
+	std::cout << std::endl << "Given Graph's MST:\n";
+	std::cout << "V1\tV2\tWeight\n";
+	for ( auto e : MST ) {
+		std::cout << e.x + 1 << "\t" << e.y + 1 << "\t" << e.r << std::endl;
+	}
+	std::cout << std::endl;
+}
+
+void inputFormat() {
+	std::cout << "Input Format:\nFirst line has two integers N, denoting the number of nodes in the graph and M,"
+				 "denoting the number of edges in the graph\n"
+				 "The next M lines each consist of three space separated integers x y r,\n"
+				 "where x and y denote the two nodes between which the undirected edge exists,"
+				 "r denotes the weight of edge between the corresponding nodes.\n";
+}
+
+int main() {
+    int N, M;
+	inputFormat();
+    std::cin >> N >> M;
+    Graph G(N, M);
+    G.getEdges();
+	std::vector<Edge> MST = G.kruskalMST();
+	printMST(MST);
+    return 0;
+}
+
+