Merge pull request #69 from TORRYNN/BackTracking

Back tracking

Author: TORRYNN

BackTracking/FindPermutation.class

@@ -0,0 +1,22 @@
+public class FindPermutation {
+ public static void Perm(String str, String ans) {
+ // Base Case
+ if (str.length() == 0) {
+ System.out.println(ans);
+ return;
+ }
+
+ for (int i = 0; i < str.length(); i++) {
+
+ char current = str.charAt(i);
+ // Deleting the current character from the string
+ String newStr = str.substring(0, i) + str.substring(i + 1);
+ Perm(newStr, ans + current);
+ }
+ }
+
+ public static void main(String args[]) {
+ Perm("abc", "");
+
+ }
+}

BackTracking/FindPermutation.java

@@ -0,0 +1,5 @@
+public class GridWay {
+ public static void main(String args[]) {
+
+ }
+}

BackTracking/GridWay.java

@@ -0,0 +1,69 @@
+public class Nqueen {
+ public static void nqueen(char board[][], int row) {
+ if (row == board.length) {
+ printBoard(board);
+ return;
+ }
+
+ for (int j = 0; j < board.length; j++) {
+ if (isSafe(board, row, j)) {
+
+ board[row][j] = 'Q';
+ nqueen(board, row + 1);
+ board[row][j] = 'X';
+ }
+ }
+ }
+
+ public static boolean isSafe(char board[][], int row, int col) {
+
+ // Vertical Up
+ for (int i = row - 1; i >= 0; i--) {
+ if (board[i][col] == 'Q') {
+ return false;
+ }
+ }
+
+ // Diagonal left Up
+ for (int i = row - 1, j = col - 1; i >= 0 && j >= 0; i--, j--) {
+ if (board[i][j] == 'Q') {
+ return false;
+ }
+ }
+
+ // Diagonal right up
+ for (int i = row - 1, j = col + 1; i >= 0 && j < board.length; i--, j++) {
+ if (board[i][j] == 'Q') {
+ return false;
+ }
+ }
+
+ return true;
+ }
+
+ public static void printBoard(char[][] board) {
+ System.out.println("----------------");
+ for (char row[] : board) {
+ for (char element : row) {
+ System.out.print(element + " ");
+ }
+ System.out.println();
+
+ }
+ }
+
+ // Time Complexity:O(n!)
+
+ public static void main(String args[]) {
+ int n = 4;
+ char board[][] = new char[n][n];
+ for (int i = 0; i < n; i++) {
+ for (int j = 0; j < n; j++) {
+ board[i][j] = 'X';
+ }
+ }
+
+ // Solve the N-Queens problem
+ nqueen(board, 0);
+ }
+}

BackTracking/Nqueen.class

@@ -0,0 +1,76 @@
+public class Nqueencount {
+
+ public static boolean nqueen(char board[][], int row) {
+ // Base Condition
+ if (row == board.length) {
+
+ return true;
+ }
+
+ for (int col = 0; col < board.length; col++) {
+ if (isSafe(board, row, col)) {
+ board[row][col] = 'Q';
+ if(nqueen(board, row + 1)){
+ return true;
+ }
+ 
+ board[row][col] = 'X';
+ }
+ }
+ return false;
+ }
+
+ public static boolean isSafe(char board[][], int row, int col) {
+ // Vertical Up
+ for (int i = row - 1; i >= 0; i--) {
+ if (board[i][col] == 'Q') {
+ return false;
+ }
+
+ }
+
+ // Diagonal left Up
+ for (int i = row - 1, j = col - 1; i >= 0 && j >= 0; i--, j--) {
+ if (board[i][j] == 'Q') {
+ return false;
+ }
+
+ }
+
+ // Diagonal right up
+ for (int i = row - 1, j = col + 1; i >= 0 && j < board.length; i--, j++) {
+ if (board[i][j] == 'Q') {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ public static void printboard(char[][] board) {
+ System.out.println("----------------");
+ for (char row[] : board) {
+ for (char element : row) {
+ System.out.print(element + " ");
+ }
+ System.out.println();
+
+ }
+ }
+
+ public static void main(String[] args) {
+ int n = 4;
+ char board[][] = new char[n][n];
+ for (int i = 0; i < n; i++) {
+ for (int j = 0; j < n; j++) {
+ board[i][j] = 'X';
+ }
+ }
+
+ // Solve the N-Queens problem
+
+ if (nqueen(board, 0)) {
+ System.out.println("Solution is possible :");
+ printboard(board);
+ }
+ }
+}

BackTracking/Nqueen.java

@@ -0,0 +1,62 @@
+// abc
+// a,b,c,bc,ac,abc
+
+public class Subset {
+ // Using Brute Force Approach
+ public static void subset1(String str) {
+ int n = str.length();
+ int totalSubsets = (int) Math.pow(2, n);
+ for (int i = 0; i < totalSubsets; i++) {
+ StringBuilder subset = new StringBuilder();
+
+ // Check each bit of the number to decide inclusion of characters
+ for (int j = 0; j < n; j++) {
+ if ((i & (1 << j)) != 0) {
+ subset.append(str.charAt(j));
+ }
+ }
+ System.out.println(subset.toString());
+ }
+
+ }
+
+ // Using BackTracking
+ public static void subset2(String str, String ans, int i) {
+ // Base Case
+
+ if (i == str.length()) {
+ if (ans.length() == 0) {
+ System.out.println("null");
+ } else {
+ System.out.println(ans);
+ }
+ return;
+ }
+ // Yes Choice
+ subset2(str, ans + str.charAt(i), i + 1);
+
+ // No Choice
+ subset2(str, ans, i + 1);
+ }
+
+ // Backtracking using Stringbuilder
+ public static void subset3(String str, StringBuilder ans, int i) {
+ if (i == str.length()) {
+ if (ans.length() == 0) {
+ System.out.println("null");
+ } else {
+ System.out.println(ans);
+ }
+ return;
+ }
+ subset3(str, new StringBuilder(ans).append(str.charAt(i)), i + 1);
+
+ subset3(str, ans, i + 1);
+ }
+
+ public static void main(String[] args) {
+ subset1("abc");
+ StringBuilder ans = new StringBuilder();
+ subset3("abcd", ans, 0);
+ }
+}

BackTracking/Nqueencount.class

@@ -0,0 +1 @@
+board