backtracking started

Author: Subham1999

src/main/java/com/thealgorithm/array/AGraphIsAValidTree.java

@@ -1,63 +1,63 @@
 package com.thealgorithm.array;
 
 public class AGraphIsAValidTree {
-    private boolean cycleExist = false;
-
-    // invoker
-    public boolean validTree(int n, int[][] edges) {
-        int[][] graph = new int[n][n];
-
-        for (int i = 0; i < edges.length; ++i) {
-            graph[edges[i][0]][edges[i][1]] = 1;
-            graph[edges[i][1]][edges[i][0]] = 1;
-        }
-
-        // Start DFS
-        boolean[] visited = new boolean[n];
-        dfs(0, -1, visited, graph);
-
-        if (cycleExist) {
-            return false;
-        }
-
-        for (int i = 0; i < n; ++i) {
-            if (!visited[i]) {
-                // That means after a single pass DFS
-                // i-th node was not visited
-                // which proves that graph is not connected
-                return false;
-            }
-        }
-
-        return true;
+  private boolean cycleExist = false;
+
+  // invoker
+  public boolean validTree(int n, int[][] edges) {
+    int[][] graph = new int[n][n];
+
+    for (int i = 0; i < edges.length; ++i) {
+      graph[edges[i][0]][edges[i][1]] = 1;
+      graph[edges[i][1]][edges[i][0]] = 1;
+    }
+
+    // Start DFS
+    boolean[] visited = new boolean[n];
+    dfs(0, -1, visited, graph);
+
+    if (cycleExist) {
+      return false;
+    }
+
+    for (int i = 0; i < n; ++i) {
+      if (!visited[i]) {
+        // That means after a single pass DFS
+        // i-th node was not visited
+        // which proves that graph is not connected
+        return false;
+      }
     }
 
-    void dfs(int node, int parent, boolean[] visited, int[][] graph) {
-        // System.out.println("- cc : " + node + " - " + parent);
-        if (!valid(graph, node)) {
-            return;
-        }
-
-        if (cycleExist) {
-            return;
-        }
-
-        if (visited[node]) {
-            //System.out.println("cc : " + node + " - " + parent);
-            cycleExist = true;
-            return;
-        }
-
-        visited[node] = true;
-
-        for (int nextNode = 0; nextNode < graph.length; ++nextNode) {
-            if (graph[node][nextNode] == 1 && nextNode != parent) {
-                dfs(nextNode, node, visited, graph);
-            }
-        }
+    return true;
+  }
+
+  void dfs(int node, int parent, boolean[] visited, int[][] graph) {
+    // System.out.println("- cc : " + node + " - " + parent);
+    if (!valid(graph, node)) {
+      return;
+    }
+
+    if (cycleExist) {
+      return;
     }
 
-    boolean valid(int[][] graph, int node) {
-        return 0 <= node && node < graph.length;
+    if (visited[node]) {
+      // System.out.println("cc : " + node + " - " + parent);
+      cycleExist = true;
+      return;
     }
+
+    visited[node] = true;
+
+    for (int nextNode = 0; nextNode < graph.length; ++nextNode) {
+      if (graph[node][nextNode] == 1 && nextNode != parent) {
+        dfs(nextNode, node, visited, graph);
+      }
+    }
+  }
+
+  boolean valid(int[][] graph, int node) {
+    return 0 <= node && node < graph.length;
+  }
 }

src/main/java/com/thealgorithm/backtracking/CombinationSumI.java

@@ -4,6 +4,10 @@
 import java.util.List;
 
 public class CombinationSumI {
+  public static void main(String[] args) {
+    System.out.println(new CombinationSumI().combinationSum(new int[] {2, 3, 6, 7}, 7));
+  }
+
   public List<List<Integer>> combinationSum(int[] candidates, int target) {
     List<List<Integer>> result = new ArrayList<>();
     List<Integer> runningSet = new ArrayList<>();
@@ -30,8 +34,4 @@ void combinationSum(
     // exclude
     combinationSum(arr, index - 1, target, result, currentSet);
   }
-
-  public static void main(String[] args) {
-    System.out.println(new CombinationSumI().combinationSum(new int[] {2, 3, 6, 7}, 7));
-  }
 }

src/main/java/com/thealgorithm/backtracking/PermutationI.java

@@ -10,6 +10,13 @@
  */
 public class PermutationI {
 
+  public static void main(String[] args) {
+    System.out.println(new PermutationI().permute(new int[] {0}));
+    System.out.println(new PermutationI().permute(new int[] {1}));
+    System.out.println(new PermutationI().permute(new int[] {1, 2}));
+    System.out.println(new PermutationI().permute(new int[] {1, 2, 3}));
+  }
+
   public List<List<Integer>> permute(int[] nums) {
     List<List<Integer>> result = new ArrayList<>();
     permute(nums, 0, result);
@@ -34,11 +41,4 @@ void swap(int[] arr, int f, int t) {
     arr[f] = arr[t];
     arr[t] = x;
   }
-
-  public static void main(String[] args) {
-    System.out.println(new PermutationI().permute(new int[] {0}));
-    System.out.println(new PermutationI().permute(new int[] {1}));
-    System.out.println(new PermutationI().permute(new int[] {1, 2}));
-    System.out.println(new PermutationI().permute(new int[] {1, 2, 3}));
-  }
 }

src/main/java/com/thealgorithm/backtracking/Subsets.java

@@ -4,6 +4,10 @@
 import java.util.List;
 
 public class Subsets {
+  public static void main(String[] args) {
+    System.out.println(new Solution().subsets(new int[] {1, 2}));
+  }
+
   static class Solution {
     public List<List<Integer>> subsets(int[] nums) {
       int len = nums.length;
@@ -26,8 +30,4 @@ public List<List<Integer>> subsets(int[] nums) {
       return result;
     }
   }
-
-  public static void main(String[] args) {
-    System.out.println(new Solution().subsets(new int[] {1, 2}));
-  }
 }

src/main/java/com/thealgorithm/backtracking/SubsetsII.java

@@ -10,6 +10,10 @@
  */
 public class SubsetsII {
 
+  public static void main(String[] args) {
+    System.out.println(new SubsetsII().subsetsWithDup(new int[] {1, 2, 2, 1, 1, 1}));
+  }
+
   public List<List<Integer>> subsetsWithDup(int[] nums) {
     int len = nums.length;
     int powerLen = 1 << len;
@@ -30,8 +34,4 @@ public List<List<Integer>> subsetsWithDup(int[] nums) {
     }
     return new ArrayList<>(result);
   }
-
-  public static void main(String[] args) {
-    System.out.println(new SubsetsII().subsetsWithDup(new int[] {1, 2, 2, 1, 1, 1}));
-  }
 }

src/main/java/com/thealgorithm/dp/lcs/LongestCommonSubsequence.java

@@ -1,7 +1,6 @@
 package com.thealgorithm.dp.lcs;
 
 import com.thealgorithm.commons.Pair;
-
 import java.util.HashMap;
 import java.util.Map;
 

src/main/java/com/thealgorithm/graph/CoursesII.java

@@ -7,6 +7,11 @@
 import java.util.Map;
 
 public class CoursesII {
+  public static void main(String[] args) {
+    System.out.println(
+        Arrays.toString(new Solution().findOrder(4, new int[][] {{1, 0}, {2, 0}, {3, 1}, {3, 2}})));
+  }
+
   static class Solution {
     private boolean cycleExists = false;
     private List<Integer> orderedList;
@@ -66,9 +71,4 @@ void dfs(Map<Integer, List<Integer>> graph, int courseLen, int node, int[] visit
       orderedList.add(node);
     }
   }
-
-  public static void main(String[] args) {
-    System.out.println(
-        Arrays.toString(new Solution().findOrder(4, new int[][] {{1, 0}, {2, 0}, {3, 1}, {3, 2}})));
-  }
 }