Added Prims Algorithm

Algorithms/Backtracking/Hamiltonian Cycle.cpp

@@ -0,0 +1,157 @@
+// This program detects any Hamiltonian Cycle in a graph 
+
+#include <bits/stdc++.h> 
+using namespace std; 
+
+// Number of vertices in the graph 
+#define V 5 
+
+void printSolution(int path[]); 
+
+/* A utility function to check if 
+the vertex v can be added at index 'pos' 
+in the Hamiltonian Cycle constructed 
+so far (stored in 'path[]') */
+bool isSafe(int v, bool graph[V][V], 
+			int path[], int pos) 
+{ 
+	/* Check if this vertex is an adjacent 
+	vertex of the previously added vertex. */
+	if (graph [path[pos - 1]][ v ] == 0) 
+		return false; 
+
+	/* Check if the vertex has already been included. 
+	This step can be optimized by creating 
+	an array of size V */
+	for (int i = 0; i < pos; i++) 
+		if (path[i] == v) 
+			return false; 
+
+	return true; 
+} 
+
+/* A recursive utility function 
+to solve hamiltonian cycle problem */
+bool hamCycleUtil(bool graph[V][V], 
+				int path[], int pos) 
+{ 
+	/* base case: If all vertices are 
+	included in Hamiltonian Cycle */
+	if (pos == V) 
+	{ 
+		// And if there is an edge from the 
+		// last included vertex to the first vertex 
+		if (graph[path[pos - 1]][path[0]] == 1) 
+			return true; 
+		else
+			return false; 
+	} 
+
+	// Try different vertices as a next candidate 
+	// in Hamiltonian Cycle. We don't try for 0 as 
+	// we included 0 as starting point in hamCycle() 
+	for (int v = 1; v < V; v++) 
+	{ 
+		/* Check if this vertex can be added 
+		// to Hamiltonian Cycle */
+		if (isSafe(v, graph, path, pos)) 
+		{ 
+			path[pos] = v; 
+
+			/* recur to construct rest of the path */
+			if (hamCycleUtil (graph, path, pos + 1) == true) 
+				return true; 
+
+			/* If adding vertex v doesn't lead to a solution, 
+			then remove it */
+			path[pos] = -1; 
+		} 
+	} 
+
+	/* If no vertex can be added to 
+	Hamiltonian Cycle constructed so far, 
+	then return false */
+	return false; 
+} 
+
+/* It mainly uses hamCycleUtil() to 
+solve the problem. It returns false if there is no 
+Hamiltonian Cycle possible, otherwise return true 
+and prints the path.*/
+bool hamCycle(bool graph[V][V]) 
+{ 
+	int *path = new int[V]; 
+	for (int i = 0; i < V; i++) 
+		path[i] = -1; 
+
+	/* Let us put vertex 0 as the first vertex in the path. 
+	If there is a Hamiltonian Cycle, then the path can be 
+	started from any point of the cycle as the graph is undirected */
+	path[0] = 0; 
+	if (hamCycleUtil(graph, path, 1) == false ) 
+	{ 
+		cout << "\nSolution does not exist"; 
+		return false; 
+	} 
+
+	printSolution(path); 
+	return true; 
+} 
+
+/* A utility function to print solution */
+void printSolution(int path[]) 
+{ 
+	cout << "Solution Exists:"
+			" Following is one Hamiltonian Cycle \n"; 
+	for (int i = 0; i < V; i++) 
+		cout << path[i] << " "; 
+
+	// Let us print the first vertex again 
+	// to show the complete cycle 
+	cout << path[0] << " "; 
+	cout << endl; 
+} 
+
+// Driver Code 
+int main() 
+{ 
+	/* Let us create the following graph 
+		(0)--(1)--(2) 
+		| / \ | 
+		| / \ | 
+		| / \ | 
+		(3)-------(4) */
+	bool graph1[V][V] = {{0, 1, 0, 1, 0}, 
+						{1, 0, 1, 1, 1}, 
+						{0, 1, 0, 0, 1}, 
+						{1, 1, 0, 0, 1}, 
+						{0, 1, 1, 1, 0}}; 
+
+	// Print the solution 
+	hamCycle(graph1); 
+
+	/* Let us create the following graph 
+	(0)--(1)--(2) 
+	| / \ | 
+	| / \ | 
+	| / \ | 
+	(3) (4) */
+	bool graph2[V][V] = {{0, 1, 0, 1, 0}, 
+						{1, 0, 1, 1, 1}, 
+						{0, 1, 0, 0, 1}, 
+						{1, 1, 0, 0, 0}, 
+						{0, 1, 1, 0, 0}}; 
+
+	// Print the solution 
+	hamCycle(graph2); 
+
+	return 0; 
+} 
+
+
+/*Output:
+Solution Exists: Following is one Hamiltonian Cycle
+ 0  1  2  4  3  0
+
+Solution does not exist
+*/

Algorithms/Backtracking/M Coloring Problem.cpp

@@ -0,0 +1,109 @@
+/* To determine if an undirected graph can be colored with atmost m colors 
+such that no two adjacent vertices are colored with the same color */
+
+#include<bits/stdc++.h> 
+
+// Number of vertices in the graph 
+#define V 4 
+
+void printSolution(int color[]); 
+
+/* A utility function to check whether the edge exists or not 
+(i.e, graph[v][i]==1). If exist then checks whether the color to 
+be filled in the new vertex(c is sent in the parameter) is already 
+used by its adjacent vertices(i-->adj vertices) or not (i.e, color[i]==c) */
+
+bool isSafe (int v, bool graph[V][V], int color[], int c) 
+{ 
+	for (int i = 0; i < V; i++) 
+		if (graph[v][i] && c == color[i]) 
+			return false; 
+	return true; 
+} 
+
+/* A recursive utility function to solve m coloring problem */
+bool graphColoringUtil(bool graph[V][V], int m, int color[], int v) 
+{ 
+	/* base case: If all vertices are assigned a color then 
+	return true */
+	if (v == V) 
+		return true; 
+
+	/* Consider this vertex v and try different colors */
+	for (int c = 1; c <= m; c++) 
+	{ 
+		/* Check if assignment of color c to v is fine*/
+		if (isSafe(v, graph, color, c)) 
+		{ 
+		color[v] = c; 
+
+		/* recur to assign colors to rest of the vertices */
+		if (graphColoringUtil (graph, m, color, v+1) == true) 
+			return true; 
+
+			/* If assigning color c doesn't lead to a solution 
+			then remove it */
+		color[v] = 0; 
+		} 
+	} 
+
+	/* If no color can be assigned to this vertex then return false */
+	return false; 
+} 
+
+/* This function returns false if the m colors cannot be assigned, otherwise return true and 
+prints assignments of colors to all vertices. */
+bool graphColoring(bool graph[V][V], int m) 
+{ 
+	// Initialize all color values as 0. This initialization is needed 
+	// correct functioning of isSafe() 
+	int color[V]; 
+	for (int i = 0; i < V; i++) 
+	color[i] = 0; 
+
+	// Call graphColoringUtil() for vertex 0 
+	if (graphColoringUtil(graph, m, color, 0) == false) 
+	{ 
+	cout<<"Solution does not exist"; 
+	return false; 
+	} 
+
+	// Print the solution 
+	printSolution(color); 
+	return true; 
+} 
+
+/* A utility function to print solution */
+void printSolution(int color[]) 
+{ 
+	cout<<"Solution Exists:Following are the assigned colors \n"; 
+	for (int i = 0; i < V; i++) 
+	cout<<" "<<color[i]<<" "; 
+	cout<<endl; 
+} 
+
+// driver program to test above function 
+int main() 
+{ 
+	/* Create following graph and test whether it is 3 colorable 
+	(3)---(2) 
+	|    / | 
+	|   /  | 
+	| /    | 
+	(0)---(1) 
+	*/
+	bool graph[V][V] = {{0, 1, 1, 1}, 
+		{1, 0, 1, 0}, 
+		{1, 1, 0, 1}, 
+		{1, 0, 1, 0}, 
+	}; 
+	int m = 3; // Number of colors 
+	graphColoring (graph, m); 
+	return 0; 
+} 
+
+
+/*Output:
+Solution Exists: Following are the assigned colors
+1  2  3  2
+*/

Algorithms/Backtracking/N Queen Problem.cpp

@@ -0,0 +1,107 @@
+/* To place N Queens on a NXN chessboard so that no two queens attack each other */
+
+#define N 4 
+#include <stdbool.h> 
+#include <stdio.h> 
+
+/* A utility function to print solution */
+void printSolution(int board[N][N]) 
+{ 
+	for (int i = 0; i < N; i++) { 
+		for (int j = 0; j < N; j++) 
+			printf(" %d ", board[i][j]); 
+		printf("\n"); 
+	} 
+} 
+
+/* A utility function to check if a queen can 
+be placed on board[row][col]. */
+bool isSafe(int board[N][N], int row, int col) 
+{ 
+	int i, j; 
+
+	/* Check this row on left side */
+	for (i = 0; i < col; i++) 
+		if (board[row][i]) 
+			return false; 
+
+	/* Check upper diagonal on left side */
+	for (i = row, j = col; i >= 0 && j >= 0; i--, j--) 
+		if (board[i][j]) 
+			return false; 
+
+	/* Check lower diagonal on left side */
+	for (i = row, j = col; j >= 0 && i < N; i++, j--) 
+		if (board[i][j]) 
+			return false; 
+
+	return true; 
+} 
+
+/* A recursive utility function to solve N 
+Queen problem */
+bool solveNQUtil(int board[N][N], int col) 
+{ 
+	/* base case: If all queens are placed 
+	then return true */
+	if (col >= N) 
+		return true; 
+
+	/* Consider this column and try placing 
+	this queen in all rows one by one */
+	for (int i = 0; i < N; i++) { 
+		/* Check if the queen can be placed on 
+		board[i][col] */
+		if (isSafe(board, i, col)) { 
+			/* Place this queen in board[i][col] */
+			board[i][col] = 1; 
+
+			/* recur to place rest of the queens */
+			if (solveNQUtil(board, col + 1)) 
+				return true; 
+
+			/* If placing queen in board[i][col] 
+			doesn't lead to a solution, then 
+			remove queen from board[i][col] */
+			board[i][col] = 0; // BACKTRACK 
+		} 
+	} 
+
+	/* If the queen cannot be placed in any row in 
+		this colum col then return false */
+	return false; 
+} 
+
+/* This function returns false if queens 
+cannot be placed, otherwise, return true and 
+prints placement of queens in the form of 1s.*/
+bool solveNQ() 
+{ 
+	int board[N][N] = { { 0, 0, 0, 0 }, 
+						{ 0, 0, 0, 0 }, 
+						{ 0, 0, 0, 0 }, 
+						{ 0, 0, 0, 0 } }; 
+
+	if (solveNQUtil(board, 0) == false) { 
+		printf("Solution does not exist"); 
+		return false; 
+	} 
+
+	printSolution(board); 
+	return true; 
+} 
+
+// driver program to test above function 
+int main() 
+{ 
+	solveNQ(); 
+	return 0; 
+} 
+
+
+/*Output:
+ 0  0  1  0 
+ 1  0  0  0 
+ 0  0  0  1 
+ 0  1  0  0 
+*/