N-Queens - Practice Coding Problems

N-Queens - Problem

Array Backtracking Hard

The n-queens puzzle is a classic problem of placing n queens on an n × n chessboard such that no two queens can attack each other.

In chess, a queen can attack any piece that lies in the same row, column, or diagonal as the queen.

Given an integer n, return all distinct solutions to the n-queens puzzle. Each solution should represent the board configuration where 'Q' indicates a queen and '.' indicates an empty space.

Input & Output

Example 1 — Classic 4-Queens

$ Input: n = 4

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

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

Example 2 — Simple 1-Queen

$ Input: n = 1

› Output: [["Q"]]

💡 Note: For a 1×1 board, there's only one position and one queen, so the single solution is just placing the queen at (0,0).

Example 3 — Impossible Case

$ 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 being on the same row, column, or diagonal.

Constraints

1 ≤ n ≤ 9

Visualization

Tap to expand

Understanding the Visualization

Input

Integer n representing board size and number of queens

Constraint

No two queens can attack each other (same row, column, or diagonal)

Output

All possible board configurations as string arrays

Key Takeaway

🎯 Key Insight: Use backtracking with constraint checking to efficiently explore only valid paths

Asked in

G Google 45 a Amazon 38 M Microsoft 32 🍎 Apple 28

The key insight is using backtracking to place queens row by row while immediately pruning invalid paths. The optimal approach uses constraint sets to track occupied columns and diagonals in O(1) time. Time: O(n!), Space: O(n)

Common Approaches

Approach	Time	Space	Notes
✓ Backtracking - Prune Invalid Paths	O(n!)	O(n)	Build solutions incrementally, backtrack when conflicts arise
Brute Force - Try All Combinations	O(n^(2n))	O(n²)	Generate all possible queen placements and filter valid ones

Backtracking - Prune Invalid Paths — Algorithm Steps

Place queens row by row from top to bottom
For each row, try each column position
Check if current placement conflicts with previous queens
If conflict, try next column; if no columns work, backtrack to previous row

Visualization

Tap to expand

Step-by-Step Walkthrough

Place Queen

Try placing queen in each column of current row

Check Conflicts

If conflicts with previous queens, try next column

Recurse/Backtrack

If valid, recurse to next row; if no valid columns, backtrack

Code -

solution.c — C

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

#define MAX_N 10
char results[1000][MAX_N][MAX_N+1];
int result_count = 0;
bool cols[MAX_N], diag1[2*MAX_N], diag2[2*MAX_N];
char board[MAX_N][MAX_N+1];

void backtrack(int row, int n) {
    if (row == n) {
        for (int i = 0; i < n; i++) {
            strcpy(results[result_count][i], board[i]);
        }
        result_count++;
        return;
    }
    
    for (int col = 0; col < n; col++) {
        if (cols[col] || diag1[row - col + n] || diag2[row + col]) {
            continue;
        }
        
        board[row][col] = 'Q';
        cols[col] = true;
        diag1[row - col + n] = true;
        diag2[row + col] = true;
        
        backtrack(row + 1, n);
        
        board[row][col] = '.';
        cols[col] = false;
        diag1[row - col + n] = false;
        diag2[row + col] = false;
    }
}

int main() {
    int n;
    scanf("%d", &n);
    
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            board[i][j] = '.';
        }
        board[i][n] = '\0';
    }
    
    memset(cols, false, sizeof(cols));
    memset(diag1, false, sizeof(diag1));
    memset(diag2, false, sizeof(diag2));
    result_count = 0;
    
    backtrack(0, n);
    
    printf("[");
    for (int i = 0; i < result_count; i++) {
        if (i > 0) printf(",");
        printf("[");
        for (int j = 0; j < n; j++) {
            if (j > 0) printf(",");
            printf("\"%s\"", results[i][j]);
        }
        printf("]");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n!)

In each row, we have fewer valid positions than the previous row

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion stack depth of n plus board storage

⚡ Linearithmic Space

156.0K Views

Medium 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

Constraints

Visualization

Related Problems

Common Approaches

Backtracking - Prune Invalid Paths — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler