Backtracking Example Problems: N-Queens & Sudoku

Problem 1: N-Queens

The N-Queens problem is about placing N chess queens on an N×N chessboard such that no two queens threaten each other. This means no two queens share the same row, column, or diagonal.

Approach

• Use backtracking to place queens row by row.
• Check if a position is safe by verifying columns and diagonals.
• If safe, place the queen and move to the next row.
• If no position is safe, backtrack to previous row.

Python Code for N-Queens

def is_safe(board, row, col, n):
    for i in range(row):
        if board[i] == col or \
           abs(board[i] - col) == abs(i - row):
            return False
    return True

def solve_n_queens(n, row=0, board=None, solutions=None):
    if board is None:
        board = [-1] * n
    if solutions is None:
        solutions = []

    if row == n:
        solutions.append(board[:])
        return

    for col in range(n):
        if is_safe(board, row, col, n):
            board[row] = col
            solve_n_queens(n, row + 1, board, solutions)
            board[row] = -1  # backtrack

# Usage example
solutions = []
solve_n_queens(4, solutions=solutions)
print("Total solutions:", len(solutions))
for solution in solutions:
    print(solution)

Problem 2: Sudoku Solver

Sudoku is a 9x9 grid where each row, column, and 3x3 sub-grid must contain numbers from 1 to 9 without repetition. The goal is to fill empty cells according to these constraints.

Approach

• Find empty cell in the grid.
• Try numbers 1-9 in the empty cell.
• Check if the number is valid in row, column, and sub-grid.
• If valid, place the number and recurse to next empty cell.
• If no number works, backtrack and change previous entries.

Python Code for Sudoku Solver

def is_valid_sudoku(board, row, col, num):
    # Check row and column
    for i in range(9):
        if board[row][i] == num or board[i][col] == num:
            return False
    # Check 3x3 sub-grid
    start_row, start_col = 3 * (row // 3), 3 * (col // 3)
    for i in range(3):
        for j in range(3):
            if board[start_row + i][start_col + j] == num:
                return False
    return True

def solve_sudoku(board):
    for row in range(9):
        for col in range(9):
            if board[row][col] == 0:  # Empty cell
                for num in range(1, 10):
                    if is_valid_sudoku(board, row, col, num):
                        board[row][col] = num
                        if solve_sudoku(board):
                            return True
                        board[row][col] = 0  # backtrack
                return False
    return True

# Example Sudoku puzzle (0 means empty)
board = [
    [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]
]

if solve_sudoku(board):
    for row in board:
        print(row)
else:
    print("No solution exists")