feat: add NeetCode 150 - Backtracking category (partial)

- Added 7 problems from Backtracking category:
  - Subsets (Java solution + explanation)
  - Combination Sum (Java solution + explanation)
  - Permutations (Java solution + explanation)
  - Subsets II (Java solution + explanation)
  - Combination Sum II (Java solution + explanation)
  - Word Search (Java solution + explanation)
  - Palindrome Partitioning (explanation)

- Multiple solution approaches for each problem
- Comprehensive explanations with algorithms and complexity analysis
- Backtracking patterns: subset generation, combination sum, permutations, duplicate handling
- DFS and state restoration techniques

Author: TechnoBlogger14o3

neetcode-150/backtracking/combination-sum-ii/explanation.md

@@ -0,0 +1,91 @@
+# Combination Sum II
+
+## Problem Statement
+
+Given a collection of candidate numbers (`candidates`) and a target number (`target`), find all unique combinations in `candidates` where the candidate numbers sum to `target`.
+
+Each number in `candidates` may only be used once in the combination.
+
+Note: The solution set must not contain duplicate combinations.
+
+## Examples
+
+**Example 1:**
+```
+Input: candidates = [10,1,2,7,6,1,5], target = 8
+Output: [[1,1,6],[1,2,5],[1,7],[2,6]]
+```
+
+**Example 2:**
+```
+Input: candidates = [2,5,2,1,2], target = 5
+Output: [[1,2,2],[5]]
+```
+
+## Approach
+
+### Method 1: Backtracking with Duplicate Handling (Recommended)
+1. Sort array to group duplicates together
+2. Use backtracking to explore all possible combinations
+3. Skip duplicates at same level to avoid duplicate combinations
+4. Use each number only once
+
+**Time Complexity:** O(2^n) - Exponential in worst case
+**Space Complexity:** O(target) - Recursion stack depth
+
+### Method 2: Dynamic Programming
+1. Use DP to build combinations bottom-up
+2. Handle duplicates by tracking previous combinations
+3. Use memoization to avoid recomputation
+
+**Time Complexity:** O(target * candidates.length)
+**Space Complexity:** O(target * candidates.length)
+
+## Algorithm
+
+```
+1. Sort candidates array
+2. Backtrack function:
+   a. If target == 0: add current combination to result
+   b. If target < 0: return (prune invalid path)
+   c. For each candidate starting from current index:
+      - Skip duplicates at same level
+      - Add candidate to combination
+      - Recursively call with target - candidate
+      - Remove candidate from combination (backtrack)
+```
+
+## Key Insights
+
+- **Sorting**: Group duplicates together
+- **Skip Duplicates**: Skip same elements at same level
+- **Single Use**: Each number used only once
+- **Pruning**: Stop when target becomes negative
+
+## Alternative Approaches
+
+1. **Dynamic Programming**: Use DP for optimization
+2. **Iterative**: Use iterative approach with stack
+3. **Set**: Use Set to automatically handle duplicates
+
+## Edge Cases
+
+- Empty candidates: Return empty list
+- Target 0: Return [[]]
+- No valid combinations: Return empty list
+- All duplicates: Handle appropriately
+
+## Applications
+
+- Combinatorics
+- Algorithm design patterns
+- Interview preparation
+- Data structure operations
+- System design
+
+## Optimization Opportunities
+
+- **Backtracking**: Most intuitive approach
+- **Early Pruning**: Stop when target < 0
+- **Sorting**: Efficient duplicate handling
+- **Skip Logic**: Avoid duplicate combinations

neetcode-150/backtracking/combination-sum-ii/solution.java

@@ -0,0 +1,227 @@
+/**
+ * Time Complexity: O(2^n) - Exponential in worst case
+ * Space Complexity: O(target) - Recursion stack depth
+ */
+class Solution {
+    public List<List<Integer>> combinationSum2(int[] candidates, int target) {
+        List<List<Integer>> result = new ArrayList<>();
+        Arrays.sort(candidates); // Sort to group duplicates
+        backtrack(candidates, target, 0, new ArrayList<>(), result);
+        return result;
+    }
+    
+    private void backtrack(int[] candidates, int target, int start, List<Integer> current, List<List<Integer>> result) {
+        if (target == 0) {
+            result.add(new ArrayList<>(current));
+            return;
+        }
+        
+        if (target < 0) {
+            return; // Prune invalid path
+        }
+        
+        for (int i = start; i < candidates.length; i++) {
+            // Skip duplicates at same level
+            if (i > start && candidates[i] == candidates[i - 1]) {
+                continue;
+            }
+            
+            if (candidates[i] > target) {
+                break; // Prune since array is sorted
+            }
+            
+            current.add(candidates[i]);
+            backtrack(candidates, target - candidates[i], i + 1, current, result);
+            current.remove(current.size() - 1); // Backtrack
+        }
+    }
+}
+
+// Alternative approach using Set
+class SolutionSet {
+    public List<List<Integer>> combinationSum2(int[] candidates, int target) {
+        Set<List<Integer>> result = new HashSet<>();
+        Arrays.sort(candidates);
+        backtrack(candidates, target, 0, new ArrayList<>(), result);
+        return new ArrayList<>(result);
+    }
+    
+    private void backtrack(int[] candidates, int target, int start, List<Integer> current, Set<List<Integer>> result) {
+        if (target == 0) {
+            result.add(new ArrayList<>(current));
+            return;
+        }
+        
+        if (target < 0) {
+            return;
+        }
+        
+        for (int i = start; i < candidates.length; i++) {
+            if (candidates[i] > target) {
+                break;
+            }
+            
+            current.add(candidates[i]);
+            backtrack(candidates, target - candidates[i], i + 1, current, result);
+            current.remove(current.size() - 1);
+        }
+    }
+}
+
+// Alternative approach using frequency map
+class SolutionFrequency {
+    public List<List<Integer>> combinationSum2(int[] candidates, int target) {
+        Map<Integer, Integer> freq = new HashMap<>();
+        for (int num : candidates) {
+            freq.put(num, freq.getOrDefault(num, 0) + 1);
+        }
+        
+        List<List<Integer>> result = new ArrayList<>();
+        backtrack(freq, target, new ArrayList<>(), result);
+        return result;
+    }
+    
+    private void backtrack(Map<Integer, Integer> freq, int target, List<Integer> current, List<List<Integer>> result) {
+        if (target == 0) {
+            result.add(new ArrayList<>(current));
+            return;
+        }
+        
+        if (target < 0) {
+            return;
+        }
+        
+        for (int num : freq.keySet()) {
+            if (freq.get(num) > 0 && num <= target) {
+                current.add(num);
+                freq.put(num, freq.get(num) - 1);
+                backtrack(freq, target - num, current, result);
+                freq.put(num, freq.get(num) + 1);
+                current.remove(current.size() - 1);
+            }
+        }
+    }
+}
+
+// Alternative approach using iterative method
+class SolutionIterative {
+    public List<List<Integer>> combinationSum2(int[] candidates, int target) {
+        List<List<Integer>> result = new ArrayList<>();
+        Stack<List<Integer>> stack = new Stack<>();
+        Stack<Integer> targetStack = new Stack<>();
+        Stack<Integer> indexStack = new Stack<>();
+        
+        stack.push(new ArrayList<>());
+        targetStack.push(target);
+        indexStack.push(0);
+        
+        while (!stack.isEmpty()) {
+            List<Integer> current = stack.pop();
+            int remainingTarget = targetStack.pop();
+            int startIndex = indexStack.pop();
+            
+            if (remainingTarget == 0) {
+                result.add(current);
+                continue;
+            }
+            
+            if (remainingTarget < 0) {
+                continue;
+            }
+            
+            for (int i = startIndex; i < candidates.length; i++) {
+                if (i > startIndex && candidates[i] == candidates[i - 1]) {
+                    continue;
+                }
+                
+                if (candidates[i] > remainingTarget) {
+                    break;
+                }
+                
+                List<Integer> newCombination = new ArrayList<>(current);
+                newCombination.add(candidates[i]);
+                stack.push(newCombination);
+                targetStack.push(remainingTarget - candidates[i]);
+                indexStack.push(i + 1);
+            }
+        }
+        
+        return result;
+    }
+}
+
+// More concise version
+class SolutionConcise {
+    public List<List<Integer>> combinationSum2(int[] candidates, int target) {
+        List<List<Integer>> result = new ArrayList<>();
+        Arrays.sort(candidates);
+        backtrack(candidates, target, 0, new ArrayList<>(), result);
+        return result;
+    }
+    
+    private void backtrack(int[] candidates, int target, int start, List<Integer> current, List<List<Integer>> result) {
+        if (target == 0) {
+            result.add(new ArrayList<>(current));
+            return;
+        }
+        
+        if (target < 0) return;
+        
+        for (int i = start; i < candidates.length; i++) {
+            if (i > start && candidates[i] == candidates[i - 1]) continue;
+            if (candidates[i] > target) break;
+            
+            current.add(candidates[i]);
+            backtrack(candidates, target - candidates[i], i + 1, current, result);
+            current.remove(current.size() - 1);
+        }
+    }
+}
+
+// Using memoization
+class SolutionMemo {
+    private Map<String, List<List<Integer>>> memo = new HashMap<>();
+    
+    public List<List<Integer>> combinationSum2(int[] candidates, int target) {
+        Arrays.sort(candidates);
+        return backtrack(candidates, target, 0);
+    }
+    
+    private List<List<Integer>> backtrack(int[] candidates, int target, int start) {
+        String key = target + "," + start;
+        if (memo.containsKey(key)) {
+            return memo.get(key);
+        }
+        
+        List<List<Integer>> result = new ArrayList<>();
+        
+        if (target == 0) {
+            result.add(new ArrayList<>());
+            return result;
+        }
+        
+        if (target < 0) {
+            return result;
+        }
+        
+        for (int i = start; i < candidates.length; i++) {
+            if (i > start && candidates[i] == candidates[i - 1]) {
+                continue;
+            }
+            
+            if (candidates[i] > target) {
+                break;
+            }
+            
+            List<List<Integer>> subResults = backtrack(candidates, target - candidates[i], i + 1);
+            for (List<Integer> subResult : subResults) {
+                List<Integer> newResult = new ArrayList<>(subResult);
+                newResult.add(candidates[i]);
+                result.add(newResult);
+            }
+        }
+        
+        memo.put(key, result);
+        return result;
+    }
+}