backtracking-patterns

name	backtracking-patterns
description	Master backtracking technique with permutations, combinations, and puzzle solving patterns with production-ready implementations.
sasmp_version	1.3.0
bonded_agent	07-greedy-advanced
bond_type	PRIMARY_BOND
atomic_responsibility	backtracking_execution
version	2.0.0
parameter_validation	{"strict":true,"rules":[{"name":"candidates","type":"list","required":true},{"name":"n","type":"integer","required":false},{"name":"k","type":"integer","required":false}]}
retry_logic	{"max_attempts":3,"backoff_ms":[100,200,400],"retryable_errors":["recursion_depth","timeout"]}
logging_hooks	{"on_start":true,"on_complete":true,"on_error":true,"log_format":"[BKT-SKILL] {timestamp} | {operation} | {status}"}
complexity_annotations	{"permutations":{"time":"O(n!)","space":"O(n)"},"combinations":{"time":"O(C(n,k))","space":"O(k)"},"n_queens":{"time":"O(n!)","space":"O(n)"},"subsets":{"time":"O(2^n)","space":"O(n)"}}

Backtracking Patterns Skill

Atomic Responsibility: Execute exhaustive search with intelligent pruning.

General Template

from typing import List, Any

def backtrack(
    candidates: List[Any],
    path: List[Any],
    result: List[List[Any]],
    start: int = 0
) -> None:
    """
    General backtracking template.

    Pattern: Choose → Explore → Unchoose
    """
    if is_solution(path):
        result.append(path[:])  # Copy path!
        return

    for i in range(start, len(candidates)):
        if not is_valid(candidates[i], path):
            continue

        # Choose
        path.append(candidates[i])

        # Explore
        backtrack(candidates, path, result, i + 1)

        # Unchoose (backtrack)
        path.pop()

Permutations

def permute(nums: List[int]) -> List[List[int]]:
    """
    Generate all permutations.

    Time: O(n!), Space: O(n)
    """
    result = []

    def backtrack(path: [], remaining: ):
          remaining:
            result.append(path[:])
            

         num  (remaining):
            path.append(num)
            remaining.remove(num)

            backtrack(path, remaining)

            path.pop()
            remaining.add(num)

    backtrack([], (nums))
     result


 () -> [[]]:
    
    result = []

     ():
         start == (nums):
            result.append(nums[:])
            

         i  (start, (nums)):
            nums[start], nums[i] = nums[i], nums[start]
            backtrack(start + )
            nums[start], nums[i] = nums[i], nums[start]

    backtrack()
     result