How can I solve the N-Queens problem using backtracking?

What is the N-Queens problem?

The N-Queens problem is a classic algorithmic problem where you need to place N queens on an N×N chessboard so that no two queens threaten each other.

How can I solve it using backtracking?

You can solve it by placing queens one by one in different columns, and for each placement, check if it leads to a solution. If not, backtrack and try the next position.

Can you provide a code example for this?

Sure! Here's a simple Python implementation using backtracking:

def solve_n_queens(n):
    def is_safe(board, row, col):
        for i in range(col):
            if board[row][i] == 'Q':
                return False
        for i, j in zip(range(row, -1, -1), range(col, -1, -1)):
            if board[i][j] == 'Q':
                return False
        for i, j in zip(range(row, n, 1), range(col, -1, -1)):
            if board[i][j] == 'Q':
                return False
        return True

    def solve(board, col):
        if col >= n:
            return True
        for i in range(n):
            if is_safe(board, i, col):
                board[i][col] = 'Q'
                if solve(board, col + 1):
                    return True
                board[i][col] = '.'
        return False

    board = [['.' for _ in range(n)] for _ in range(n)]
    solve(board, 0)
    return board

This code defines a function to solve the N-Queens problem.

What are the time complexity and space complexity of this solution?

The time complexity of the backtracking solution for the N-Queens problem is O(N!), and the space complexity is O(N) due to the recursion stack.