Merge pull request #460 from shubhamgpt198/master

Karger's Algo/C++/Karger_Algo.cpp

Author: probot-auto-merge[bot]

Graph Algorithms/Karger's Algo/C++/Karger_Algo.cpp

@@ -0,0 +1,193 @@
+// Karger's algorithm to find Minimum Cut in an 
+// undirected, unweighted and connected graph. 
+#include <stdio.h> 
+#include <stdlib.h> 
+#include <time.h> 
+
+// a structure to represent a unweighted edge in graph 
+struct edge 
+{ 
+	int src, dest; 
+}; 
+
+// a structure to represent a connected, undirected 
+// and unweighted graph as a collection of edges. 
+struct Graph 
+{ 
+	// 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; 
+}; 
+
+// A structure to represent a sub_set for union-find 
+struct sub_set 
+{ 
+	int parent; 
+	int rank; 
+}; 
+
+// Function prototypes for union-find (These functions are defined 
+// after karger_min_cut() ) 
+int find(struct sub_set subsets[], int i); 
+void union(struct sub_set subsets[], int x, int y); 
+
+// A very basic implementation of Karger's randomized 
+// algorithm for finding the minimum cut. Please note 
+// that Karger's algorithm is a Monte Carlo Randomized algo 
+// and the cut returned by the algorithm may not be 
+// minimum always 
+int karger_min_cut(struct Graph* graph) 
+{ 
+	// Get data of given graph 
+	int V = graph->V, E = graph->E; 
+	edge *edge = graph->edge; 
+
+	// Allocate memory for creating V subsets. 
+	struct sub_set *subsets = new sub_set[V]; 
+
+	// Create V subsets with single elements 
+	for (int v = 0; v < V; ++v) 
+	{ 
+		subsets[v].parent = v; 
+		subsets[v].rank = 0; 
+	} 
+
+	// Initially there are V vertices in 
+	// contracted graph 
+	int vertices = V; 
+
+	// Keep contracting vertices until there are 
+	// 2 vertices. 
+	while (vertices > 2) 
+	{ 
+	// Pick a random edge 
+	int i = rand() % E; 
+
+	// Find vertices (or sets) of two corners 
+	// of current edge 
+	int subset1 = find(subsets, edge[i].src); 
+	int subset2 = find(subsets, edge[i].dest); 
+
+	// If two corners belong to same sub_set, 
+	// then no point considering this edge 
+	if (subset1 == subset2) 
+		continue; 
+
+	// Else contract the edge (or combine the 
+	// corners of edge into one vertex) 
+	else
+	{ 
+		printf("Contracting edge %d-%d\n", 
+				edge[i].src, edge[i].dest); 
+		vertices--; 
+		union(subsets, subset1, subset2); 
+	} 
+	} 
+
+	// Now we have two vertices (or subsets) left in 
+	// the contracted graph, so count the edges between 
+	// two components and return the count. 
+	int cutedges = 0; 
+	for (int i=0; i<E; i++) 
+	{ 
+		int subset1 = find(subsets, edge[i].src); 
+		int subset2 = find(subsets, edge[i].dest); 
+		if (subset1 != subset2) 
+		cutedges++; 
+	} 
+
+	return cutedges; 
+} 
+
+// A utility function to find set of an element i 
+// (uses path compression technique) 
+int find(struct sub_set 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(struct sub_set 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++; 
+	} 
+} 
+
+// Creates a graph with V vertices and E edges 
+struct Graph* create_graph(int V, int E) 
+{ 
+	Graph* graph = new Graph; 
+	graph->V = V; 
+	graph->E = E; 
+	graph->edge = new edge[E]; 
+	return graph; 
+} 
+
+// Driver program to test above functions 
+int main() 
+{ 
+	/* Let us create following unweighted graph 
+		0------1 
+		| \ | 
+		| \ | 
+		|	 \| 
+		2------3 */
+	int V = 4; // Number of vertices in graph 
+	int E = 5; // Number of edges in graph 
+	struct Graph* graph = create_graph(V, E); 
+
+	// add edge 0-1 
+	graph->edge[0].src = 0; 
+	graph->edge[0].dest = 1; 
+
+	// add edge 0-2 
+	graph->edge[1].src = 0; 
+	graph->edge[1].dest = 2; 
+
+	// add edge 0-3 
+	graph->edge[2].src = 0; 
+	graph->edge[2].dest = 3; 
+
+	// add edge 1-3 
+	graph->edge[3].src = 1; 
+	graph->edge[3].dest = 3; 
+
+	// add edge 2-3 
+	graph->edge[4].src = 2; 
+	graph->edge[4].dest = 3; 
+
+	// Use a different seed value for every run. 
+	srand(time(NULL)); 
+
+	printf("\nCut found by Karger's randomized algo is %d\n", 
+		karger_min_cut(graph)); 
+
+	return 0; 
+}