feat: add complete backtracking problem implementations

- Fix solution comments to follow SOLUTION_CONTRACT.md A.7.2 format
- Add JUDGE_FUNC for generator support to all 12 backtracking problems
- Create test cases (.in/.out) for problems 0039, 0040, 0046, 0047,
  0052, 0077, 0078, 0079, 0090, 0093, 0131, 0216
- Add generators following GENERATOR_CONTRACT.md
- Update ontology with backtracking patterns and families

Author: lufftw

generators/0039_combination_sum.py

@@ -0,0 +1,62 @@
+# generators/0039_combination_sum.py
+"""
+Test Case Generator for Problem 0039 - Combination Sum
+
+LeetCode Constraints:
+- 1 <= candidates.length <= 30
+- 2 <= candidates[i] <= 40
+- All elements of candidates are distinct
+- 1 <= target <= 40
+"""
+import random
+from typing import Iterator, Optional
+
+
+def generate(count: int = 10, seed: Optional[int] = None) -> Iterator[str]:
+    """
+    Generate test case inputs for Combination Sum.
+    
+    Args:
+        count: Number of test cases to generate
+        seed: Random seed for reproducibility
+    
+    Yields:
+        str: Test input in the format: candidates\\ntarget
+    """
+    if seed is not None:
+        random.seed(seed)
+    
+    # Edge cases first
+    edge_cases = [
+        "2,3,6,7\n7",        # Classic example
+        "2,3,5\n8",          # Multiple combinations
+        "2\n1",              # No solution
+        "7,8,9\n7",          # Single element solution
+    ]
+    
+    for edge in edge_cases:
+        yield edge
+        count -= 1
+        if count <= 0:
+            return
+    
+    # Random cases
+    for _ in range(count):
+        yield _generate_case()
+
+
+def _generate_case() -> str:
+    """Generate a single random test case."""
+    # Random number of candidates (2-15 for reasonable test size)
+    n = random.randint(2, 15)
+    
+    # Generate distinct candidates in range [2, 40]
+    candidates = random.sample(range(2, 41), min(n, 39))
+    
+    # Generate target that is likely achievable
+    min_candidate = min(candidates)
+    target = random.randint(min_candidate, 40)
+    
+    candidates_str = ','.join(map(str, candidates))
+    return f"{candidates_str}\n{target}"
+

generators/0040_combination_sum_ii.py

@@ -0,0 +1,60 @@
+# generators/0040_combination_sum_ii.py
+"""
+Test Case Generator for Problem 0040 - Combination Sum II
+
+LeetCode Constraints:
+- 1 <= candidates.length <= 100
+- 1 <= candidates[i] <= 50
+- 1 <= target <= 30
+"""
+import random
+from typing import Iterator, Optional
+
+
+def generate(count: int = 10, seed: Optional[int] = None) -> Iterator[str]:
+    """
+    Generate test case inputs for Combination Sum II.
+    
+    Args:
+        count: Number of test cases to generate
+        seed: Random seed for reproducibility
+    
+    Yields:
+        str: Test input in the format: candidates\\ntarget
+    """
+    if seed is not None:
+        random.seed(seed)
+    
+    # Edge cases first
+    edge_cases = [
+        "10,1,2,7,6,1,5\n8",   # Classic with duplicates
+        "2,5,2,1,2\n5",        # Multiple duplicates
+        "1,1,1,1,1\n3",        # All same
+        "2\n1",                # No solution
+    ]
+    
+    for edge in edge_cases:
+        yield edge
+        count -= 1
+        if count <= 0:
+            return
+    
+    # Random cases
+    for _ in range(count):
+        yield _generate_case()
+
+
+def _generate_case() -> str:
+    """Generate a single random test case with possible duplicates."""
+    # Random number of candidates (2-20 for reasonable test size)
+    n = random.randint(2, 20)
+    
+    # Generate candidates with possible duplicates
+    candidates = [random.randint(1, 50) for _ in range(n)]
+    
+    # Generate target in valid range
+    target = random.randint(1, 30)
+    
+    candidates_str = ','.join(map(str, candidates))
+    return f"{candidates_str}\n{target}"
+

generators/0046_permutations.py

@@ -0,0 +1,57 @@
+# generators/0046_permutations.py
+"""
+Test Case Generator for Problem 0046 - Permutations
+
+LeetCode Constraints:
+- 1 <= nums.length <= 6
+- -10 <= nums[i] <= 10
+- All the integers of nums are unique
+"""
+import random
+from typing import Iterator, Optional
+
+
+def generate(count: int = 10, seed: Optional[int] = None) -> Iterator[str]:
+    """
+    Generate test case inputs for Permutations.
+    
+    Args:
+        count: Number of test cases to generate
+        seed: Random seed for reproducibility
+    
+    Yields:
+        str: Test input in the format: nums (comma-separated)
+    """
+    if seed is not None:
+        random.seed(seed)
+    
+    # Edge cases first
+    edge_cases = [
+        "1",           # Single element
+        "1,2",         # Two elements
+        "1,2,3",       # Classic example
+        "0,-1,1",      # With negatives
+        "1,2,3,4,5,6", # Maximum length
+    ]
+    
+    for edge in edge_cases:
+        yield edge
+        count -= 1
+        if count <= 0:
+            return
+    
+    # Random cases
+    for _ in range(count):
+        yield _generate_case()
+
+
+def _generate_case() -> str:
+    """Generate a single random test case with distinct integers."""
+    # Random length 1-6
+    n = random.randint(1, 6)
+    
+    # Generate distinct integers in range [-10, 10]
+    nums = random.sample(range(-10, 11), n)
+    
+    return ','.join(map(str, nums))
+

generators/0047_permutations_ii.py

@@ -0,0 +1,56 @@
+# generators/0047_permutations_ii.py
+"""
+Test Case Generator for Problem 0047 - Permutations II
+
+LeetCode Constraints:
+- 1 <= nums.length <= 8
+- -10 <= nums[i] <= 10
+"""
+import random
+from typing import Iterator, Optional
+
+
+def generate(count: int = 10, seed: Optional[int] = None) -> Iterator[str]:
+    """
+    Generate test case inputs for Permutations II.
+    
+    Args:
+        count: Number of test cases to generate
+        seed: Random seed for reproducibility
+    
+    Yields:
+        str: Test input in the format: nums (comma-separated)
+    """
+    if seed is not None:
+        random.seed(seed)
+    
+    # Edge cases first
+    edge_cases = [
+        "1,1,2",           # Classic with duplicates
+        "1,2,3",           # No duplicates
+        "1,1,1",           # All same
+        "1,1,2,2",         # Pairs of duplicates
+        "0,0,0,0",         # All zeros
+    ]
+    
+    for edge in edge_cases:
+        yield edge
+        count -= 1
+        if count <= 0:
+            return
+    
+    # Random cases
+    for _ in range(count):
+        yield _generate_case()
+
+
+def _generate_case() -> str:
+    """Generate a single random test case with possible duplicates."""
+    # Random length 1-8
+    n = random.randint(1, 8)
+    
+    # Generate integers with possible duplicates
+    nums = [random.randint(-10, 10) for _ in range(n)]
+    
+    return ','.join(map(str, nums))
+

generators/0052_n_queens_ii.py

@@ -0,0 +1,39 @@
+# generators/0052_n_queens_ii.py
+"""
+Test Case Generator for Problem 0052 - N-Queens II
+
+LeetCode Constraints:
+- 1 <= n <= 9
+"""
+import random
+from typing import Iterator, Optional
+
+
+def generate(count: int = 10, seed: Optional[int] = None) -> Iterator[str]:
+    """
+    Generate test case inputs for N-Queens II.
+    
+    Args:
+        count: Number of test cases to generate
+        seed: Random seed for reproducibility
+    
+    Yields:
+        str: Test input - a single integer n
+    """
+    if seed is not None:
+        random.seed(seed)
+    
+    # Edge cases first (all valid n values)
+    edge_cases = ["1", "4", "8", "9"]
+    
+    for edge in edge_cases:
+        yield edge
+        count -= 1
+        if count <= 0:
+            return
+    
+    # Random cases
+    for _ in range(count):
+        n = random.randint(1, 9)
+        yield str(n)
+

generators/0077_combinations.py

@@ -0,0 +1,53 @@
+# generators/0077_combinations.py
+"""
+Test Case Generator for Problem 0077 - Combinations
+
+LeetCode Constraints:
+- 1 <= n <= 20
+- 1 <= k <= n
+"""
+import random
+from typing import Iterator, Optional
+
+
+def generate(count: int = 10, seed: Optional[int] = None) -> Iterator[str]:
+    """
+    Generate test case inputs for Combinations.
+    
+    Args:
+        count: Number of test cases to generate
+        seed: Random seed for reproducibility
+    
+    Yields:
+        str: Test input in the format: n\\nk
+    """
+    if seed is not None:
+        random.seed(seed)
+    
+    # Edge cases first
+    edge_cases = [
+        "4\n2",   # Classic example
+        "1\n1",   # Minimal
+        "5\n5",   # k equals n
+        "5\n1",   # k equals 1
+        "10\n3",  # Larger case
+    ]
+    
+    for edge in edge_cases:
+        yield edge
+        count -= 1
+        if count <= 0:
+            return
+    
+    # Random cases
+    for _ in range(count):
+        yield _generate_case()
+
+
+def _generate_case() -> str:
+    """Generate a single random test case."""
+    # Keep n reasonable to avoid explosion (C(20,10) is large)
+    n = random.randint(1, 12)
+    k = random.randint(1, n)
+    return f"{n}\n{k}"
+

generators/0078_subsets.py

@@ -0,0 +1,56 @@
+# generators/0078_subsets.py
+"""
+Test Case Generator for Problem 0078 - Subsets
+
+LeetCode Constraints:
+- 1 <= nums.length <= 10
+- -10 <= nums[i] <= 10
+- All the numbers of nums are unique
+"""
+import random
+from typing import Iterator, Optional
+
+
+def generate(count: int = 10, seed: Optional[int] = None) -> Iterator[str]:
+    """
+    Generate test case inputs for Subsets.
+    
+    Args:
+        count: Number of test cases to generate
+        seed: Random seed for reproducibility
+    
+    Yields:
+        str: Test input in the format: nums (comma-separated)
+    """
+    if seed is not None:
+        random.seed(seed)
+    
+    # Edge cases first
+    edge_cases = [
+        "1,2,3",     # Classic example
+        "0",         # Single element
+        "1,2",       # Two elements
+        "1,2,3,4",   # Four elements
+    ]
+    
+    for edge in edge_cases:
+        yield edge
+        count -= 1
+        if count <= 0:
+            return
+    
+    # Random cases
+    for _ in range(count):
+        yield _generate_case()
+
+
+def _generate_case() -> str:
+    """Generate a single random test case with unique integers."""
+    # Random length 1-10
+    n = random.randint(1, 10)
+    
+    # Generate distinct integers in range [-10, 10]
+    nums = random.sample(range(-10, 11), n)
+    
+    return ','.join(map(str, nums))
+