N-Queens - Practice Coding Problems

N-Queens - Problem

Array Backtracking Hard

The N-Queens Problem is a classic chess puzzle that challenges you to place n queens on an n × n chessboard such that no two queens can attack each other.

In chess, a queen can attack any piece in the same row, column, or diagonal. Your task is to find all possible arrangements where n queens coexist peacefully on the board.

Input: An integer n representing the size of the chessboard
Output: A list of all distinct solutions, where each solution is represented as a list of strings. Each string represents a row of the chessboard, with 'Q' indicating a queen and '.' indicating an empty space.

For example, with n = 4, one valid solution would place queens at positions that don't threaten each other, creating a safe configuration for all pieces.

Input & Output

example_1.py — Python

$ Input: n = 4

› Output: [[".Q..","...Q","Q...","..Q."], ["..Q.","Q...","...Q",".Q.."]]

💡 Note: For a 4×4 board, there are exactly 2 distinct solutions. In the first solution, queens are placed at (0,1), (1,3), (2,0), (3,2). In the second solution, queens are at (0,2), (1,0), (2,3), (3,1). Both arrangements ensure no two queens can attack each other.

example_2.py — Python

$ Input: n = 1

› Output: [["Q"]]

💡 Note: For a 1×1 board, there's only one solution: place the single queen in the only available position. This is the trivial base case.

example_3.py — Python

$ Input: n = 2

› Output: []

💡 Note: For a 2×2 board, it's impossible to place 2 queens without them attacking each other. Any placement will result in queens sharing the same row, column, or diagonal, so the result is an empty list.

Visualization

Tap to expand

Understanding the Visualization

Initialize Board

Start with empty 4×4 board and tracking arrays for columns and diagonals

Place First Queen

Place queen in row 0, try each column until finding valid position

Recursive Placement

Move to next row, place queen avoiding conflicts with previous queens

Backtrack on Conflict

When no valid position exists, remove last queen and try next position

Solution Found

When all rows filled successfully, record the solution and continue search

Key Takeaway

🎯 Key Insight: Backtracking with constraint tracking reduces the search space from n! permutations to a much smaller tree by eliminating invalid partial solutions early.

Time & Space Complexity

Time Complexity

⏱️

O(N!)

In the worst case, we might need to try N positions in first row, N-2 in second, etc., leading to roughly N! combinations, but with heavy pruning

✓ Linear Growth

Space Complexity

O(N)

Recursion stack depth is N, plus arrays to track column and diagonal usage

✓ Linear Space

Constraints

1 ≤ n ≤ 9
Each solution contains a distinct board configuration
Solutions can be returned in any order
Board representation uses 'Q' for queens and '.' for empty spaces

Asked in

G Google 85 a Amazon 72 f Meta 68 ⊞ Microsoft 61

The optimal solution uses backtracking to place queens row by row, immediately backtracking when conflicts arise. Key optimizations include using boolean arrays to track occupied columns and diagonals, achieving O(N!) time complexity with significant pruning.

Common Approaches

Approach	Time	Space	Notes
✓ Backtracking (Optimal)	O(N!)	O(N)	Place queens row by row, backtrack when conflicts arise
Brute Force (Generate All Permutations)	O(n! × n)	O(n)	Generate all possible queen placements and check each for conflicts

Backtracking (Optimal) — Algorithm Steps

Start with an empty board and place queens row by row
For each row, try placing a queen in each column
Before placing, check if the position conflicts with existing queens
If no conflict, place the queen and recursively solve the next row
If all rows are filled, we found a valid solution
If no valid position exists in a row, backtrack to the previous row

Visualization

Tap to expand

Step-by-Step Walkthrough

Place First Queen

Try placing queen in row 0, column 0

Check Next Row

Row 1: columns 0,1 blocked by diagonals, try column 2

Conflict Found

Row 2: all positions conflict, backtrack to row 1

Try Next Position

Move queen in row 1 to next valid position

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <string.h>

typedef struct {
    char** solutions;
    int count;
    int capacity;
} ResultSet;

static bool* cols;
static bool* diag1;
static bool* diag2;
static int* board;
static int n;

void addSolution(ResultSet* results) {
    if (results->count >= results->capacity) {
        results->capacity *= 2;
        results->solutions = realloc(results->solutions, 
                                   results->capacity * n * sizeof(char*));
    }
    
    for (int i = 0; i < n; i++) {
        char* row = malloc((n + 1) * sizeof(char));
        for (int j = 0; j < n; j++) {
            row[j] = (j == board[i]) ? 'Q' : '.';
        }
        row[n] = '\0';
        results->solutions[results->count * n + i] = row;
    }
    results->count++;
}

void backtrack(int row, ResultSet* results) {
    if (row == n) {
        addSolution(results);
        return;
    }
    
    for (int col = 0; col < n; col++) {
        if (!cols[col] && !diag1[row - col + n - 1] && !diag2[row + col]) {
            cols[col] = diag1[row - col + n - 1] = diag2[row + col] = true;
            board[row] = col;
            
            backtrack(row + 1, results);
            
            cols[col] = diag1[row - col + n - 1] = diag2[row + col] = false;
        }
    }
}

int main() {
    scanf("%d", &n);
    
    board = malloc(n * sizeof(int));
    cols = malloc(n * sizeof(bool));
    diag1 = malloc((2 * n - 1) * sizeof(bool));
    diag2 = malloc((2 * n - 1) * sizeof(bool));
    
    for (int i = 0; i < n; i++) cols[i] = false;
    for (int i = 0; i < 2 * n - 1; i++) {
        diag1[i] = diag2[i] = false;
    }
    
    ResultSet results = {NULL, 0, 10};
    results.solutions = malloc(results.capacity * n * sizeof(char*));
    
    backtrack(0, &results);
    
    for (int i = 0; i < results.count; i++) {
        for (int j = 0; j < n; j++) {
            printf("%s\n", results.solutions[i * n + j]);
            free(results.solutions[i * n + j]);
        }
    }
    
    free(results.solutions);
    free(board);
    free(cols);
    free(diag1);
    free(diag2);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(N!)

In the worst case, we might need to try N positions in first row, N-2 in second, etc., leading to roughly N! combinations, but with heavy pruning

✓ Linear Growth

Space Complexity

O(N)

Recursion stack depth is N, plus arrays to track column and diagonal usage

✓ Linear Space

Constraints

1 ≤ n ≤ 9
Each solution contains a distinct board configuration
Solutions can be returned in any order
Board representation uses 'Q' for queens and '.' for empty spaces

68.3K Views

High Frequency

~25 min Avg. Time

2.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Backtracking (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler