Your concept feed

def subsets(values):
    answers, path = [], []
    def visit(i):
        if i == len(values):
            answers.append(path.copy())
            return
        visit(i + 1)               # Exclude this item.
        path.append(values[i])     # Include this item.
        visit(i + 1)
        path.pop()                 # Restore the caller's path.
    visit(0)
    return answers

assert subsets(["A", "B"]) == [[], ["B"], ["A"], ["A", "B"]]
assert subsets([]) == [[]]

def unique_subsets(values):
    values = sorted(values)
    answers, path = [], []
    def visit(start):
        answers.append(path.copy())
        for i in range(start, len(values)):
            if i > start and values[i] == values[i - 1]:
                continue
            path.append(values[i])
            visit(i + 1)
            path.pop()
    visit(0)
    return answers

assert unique_subsets([1, 1, 2]) == [[], [1], [1, 1], [1, 1, 2], [1, 2], [2]]

def count_queens(n):
    if n < 0: raise ValueError("Negative n")
    columns, down, up = set(), set(), set()
    def place(row):
        if row == n: return 1
        total = 0
        for column in range(n):
            marks = column, row-column, row+column
            if marks[0] in columns or marks[1] in down or marks[2] in up: continue
            columns.add(marks[0]); down.add(marks[1]); up.add(marks[2])
            total += place(row+1)
            columns.remove(marks[0]); down.remove(marks[1]); up.remove(marks[2])
        return total
    return place(0)

assert count_queens(0) == 1
assert count_queens(4) == 2
assert count_queens(5) == 10

def solve_sudoku(board):
    digits = set(range(1,10))
    rows, cols, boxes = [set() for _ in range(9)], [set() for _ in range(9)], [set() for _ in range(9)]
    blanks = []
    for r in range(9):
        for c in range(9):
            value = board[r][c]
            box = (r//3)*3+c//3
            if value == 0: blanks.append((r,c))
            elif value not in digits or value in rows[r] or value in cols[c] or value in boxes[box]:
                return False
            else: rows[r].add(value); cols[c].add(value); boxes[box].add(value)
    def search():
        if not blanks: return True
        best = min(range(len(blanks)), key=lambda i: len(digits-rows[blanks[i][0]]-cols[blanks[i][1]]-boxes[(blanks[i][0]//3)*3+blanks[i][1]//3]))
        r, c = blanks.pop(best); box = (r//3)*3+c//3
        for value in sorted(digits-rows[r]-cols[c]-boxes[box]):
            board[r][c] = value; rows[r].add(value); cols[c].add(value); boxes[box].add(value)
            if search(): return True
            rows[r].remove(value); cols[c].remove(value); boxes[box].remove(value)
        board[r][c] = 0; blanks.insert(best,(r,c))
        return False
    return search()

puzzle = [[5,3,0,0,7,0,0,0,0],[6,0,0,1,9,5,0,0,0],[0,9,8,0,0,0,0,6,0],[8,0,0,0,6,0,0,0,3],[4,0,0,8,0,3,0,0,1],[7,0,0,0,2,0,0,0,6],[0,6,0,0,0,0,2,8,0],[0,0,0,4,1,9,0,0,5],[0,0,0,0,8,0,0,7,9]]
assert solve_sudoku(puzzle)
assert all(set(row) == set(range(1,10)) for row in puzzle)

def unique_permutations(values):
    values = sorted(values)
    used = [False] * len(values)
    answer, path = [], []
    def build():
        if len(path) == len(values):
            answer.append(path[:]); return
        for i, value in enumerate(values):
            if used[i] or (i and values[i] == values[i-1] and not used[i-1]): continue
            used[i] = True; path.append(value)
            build()
            path.pop(); used[i] = False
    build()
    return answer

assert unique_permutations([1,1,2]) == [[1,1,2],[1,2,1],[2,1,1]]
assert unique_permutations([]) == [[]]

def combination_sum(candidates, target):
    if target < 0 or any(value <= 0 for value in candidates) or len(set(candidates)) != len(candidates):
        raise ValueError("Invalid input")
    candidates = sorted(candidates)
    answer, path = [], []
    def build(start, remaining):
        if remaining == 0:
            answer.append(path[:]); return
        for i in range(start, len(candidates)):
            value = candidates[i]
            if value > remaining: break
            path.append(value); build(i, remaining-value); path.pop()
    build(0, target)
    return answer

assert combination_sum([2,3,6,7], 7) == [[2,2,3],[7]]
assert combination_sum([2], 1) == []