completed Backtracking-2

PalindromePartitioning.java

@@ -0,0 +1,81 @@
+import java.util.ArrayList;
+import java.util.List;
+class PalindromePartitioning {
+    List<List<String>> result;
+    public List<List<String>> partition(String s) {
+        result = new ArrayList<>();
+        // partitionHelper(s, new ArrayList<>(), 0, 0);
+        partitionHelper(s, new ArrayList<>(), 0);
+        return result;
+    }
+
+    // private void partitionHelper(String s, List<String> path, int pivot, int i, int sizeofpartitions)
+    private void partitionHelper(String s, List<String> path, int pivot)
+    {
+        // // a. recursion with choose and not choose + backtracking
+        // // base
+        // if(i == s.length())
+        // {
+        //     if(s.length() == sizeofpartitions)
+        //     {
+        //         // add if all char of s are part of partitions
+        //         result.add(new ArrayList<>(path));
+        //     }
+        //     return;
+        // }
+
+        // // logic
+        //     // action
+        //     // recurse
+        // // not choose
+        // partitionHelper(s, path, pivot, i+1, sizeofpartitions);
+        // // choose
+        // String substr = s.substring(pivot, i+1);
+        // if(isPalindrome(substr))
+        // {
+        //     path.add(substr);
+        //     partitionHelper(s, path, i+1, i+1, sizeofpartitions+substr.length());
+        //         // backtrack
+        //     path.remove(path.size() - 1);
+        // }
+
+        // b. recursion + for loop + backtrack
+        // base
+        if(pivot == s.length())
+        {
+            result.add(new ArrayList<>(path));
+            return;
+        }
+
+        // logic
+        for(int i = pivot; i < s.length(); i++)
+        {
+            // action
+            String substr = s.substring(pivot, i+1);
+            // recurse
+            if(isPalindrome(substr))
+            {
+                path.add(substr);
+                partitionHelper(s, path, i+1);
+                // backtrack
+                path.remove(path.size() - 1);
+            }
+        }
+    }
+
+    private boolean isPalindrome(String s)
+    {
+        int left = 0, right = s.length() -1;
+        while(left <= right)
+        {
+            if(s.charAt(left) != s.charAt(right))
+            {
+                return false;
+            }
+            left++;
+            right--;
+        }
+
+        return true;
+    }
+}

Subsets.java

@@ -0,0 +1,47 @@
+import java.util.ArrayList;
+import java.util.List;
+class Subsets {
+    List<List<Integer>> result;
+    public List<List<Integer>> subsets(int[] nums) {
+        result = new ArrayList<>();
+        subsetHelper(nums, new ArrayList<>(), 0);
+        return result;
+    }
+
+    // private void subsetHelper(int[] nums, List<Integer> subset, int idx)
+    private void subsetHelper(int[] nums, List<Integer> subset, int pivot)
+    {
+        // // a. using recursion + backtracking
+        // // base
+        // if(idx == nums.length)
+        // {
+        //     result.add(new ArrayList<>(subset));
+        //     return;
+        // }
+
+        // // logic
+        // // action - choose and not choose
+        // // recurse
+        // // not choose
+        // subsetHelper(nums, subset, idx+1);
+        // // choose
+        // subset.add(nums[idx]);
+        // subsetHelper(nums, subset, idx+1);
+        // // backtrack
+        // subset.remove(subset.size() - 1);
+
+        // b. using recursion + for loop + backtracking
+        // base
+        result.add(new ArrayList<>(subset));
+
+        // action
+        for(int i = pivot; i < nums.length; i++)
+        {
+            subset.add(nums[i]);
+            // recurse
+            subsetHelper(nums, subset, i+1);
+            // backtrack
+            subset.remove(subset.size() - 1);
+        }
+    }
+}