N-Queens II - Practice Coding Problems

N-Queens II - Problem

Backtracking Hard

The N-Queens II problem is a classic backtracking puzzle that challenges you to count the number of ways to place n chess queens on an n × n chessboard.

The Challenge: Queens are powerful pieces that can attack any piece in the same row, column, or diagonal. Your task is to find how many distinct arrangements exist where no two queens can attack each other.

Input: An integer n representing the size of the chessboard and the number of queens to place.

Output: The total count of valid arrangements (solutions).

Example: For n = 4, there are exactly 2 distinct solutions where 4 queens can be placed on a 4×4 board without attacking each other.

Input & Output

example_1.py — Basic Case

$ Input: n = 4

› Output: 2

💡 Note: For a 4×4 board, there are exactly 2 ways to place 4 queens such that none attack each other. The two solutions have queens at positions [(0,1),(1,3),(2,0),(3,2)] and [(0,2),(1,0),(2,3),(3,1)].

example_2.py — Small Case

$ Input: n = 1

› Output: 1

💡 Note: On a 1×1 board, there's only one way to place 1 queen - at position (0,0).

example_3.py — Impossible Case

$ Input: n = 2

› Output: 0

💡 Note: On a 2×2 board, it's impossible to place 2 queens without them attacking each other, since any two positions will share a row, column, or diagonal.

Constraints

1 ≤ n ≤ 9
The problem guarantees that n will be small enough to compute in reasonable time
Note: For n ≥ 10, the computation time becomes prohibitively long even with optimal algorithms

Visualization

Tap to expand

Understanding the Visualization

Initialize

Start with empty board and conflict tracking sets

Place Queen

Try placing a queen in the first available position of current row

Update Conflicts

Add the queen's attack lines to conflict sets

Recurse or Backtrack

If valid, move to next row. If no valid positions remain, backtrack

Count Solution

When all n queens are placed successfully, increment solution count

Key Takeaway

🎯 Key Insight: Using conflict detection sets transforms an O(n) validity check into O(1), making backtracking dramatically more efficient by pruning invalid branches immediately.

Asked in

G Google 45 a Amazon 38 ⊞ Microsoft 32 f Meta 28

The optimal solution uses backtracking with conflict detection sets. By maintaining three hash sets to track occupied columns, main diagonals (row-col), and anti-diagonals (row+col), we can detect conflicts in O(1) time and prune invalid branches early. This approach typically performs much better than the theoretical O(n!) worst case due to aggressive pruning.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Generate All Permutations)	O(n!)	O(n)	Generate all possible queen placements and check each for validity
Backtracking with Conflict Detection (Optimal)	O(n!)	O(n)	Use backtracking with efficient conflict detection using sets

Brute Force (Generate All Permutations) — Algorithm Steps

Generate all permutations of column positions for n rows
For each permutation, check if any two queens are on the same diagonal
Count valid permutations where no diagonal conflicts exist
Return the total count

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Permutation

Create a permutation of column positions [0,1,2,3] for 4 queens

Check Diagonals

For each pair of queens, verify they're not on the same diagonal

Count Valid

If no diagonal conflicts exist, increment the solution count

Next Permutation

Generate the next permutation and repeat the process

Code -

solution.c — C

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

bool isValid(int* positions, int n) {
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
            if (abs(positions[i] - positions[j]) == abs(i - j)) {
                return false;
            }
        }
    }
    return true;
}

void generatePermutations(int* arr, int* current, bool* used, int pos, int n, int* count) {
    if (pos == n) {
        if (isValid(current, n)) {
            (*count)++;
        }
        return;
    }
    
    for (int i = 0; i < n; i++) {
        if (!used[i]) {
            used[i] = true;
            current[pos] = arr[i];
            generatePermutations(arr, current, used, pos + 1, n, count);
            used[i] = false;
        }
    }
}

int totalNQueens(int n) {
    int* arr = (int*)malloc(n * sizeof(int));
    int* current = (int*)malloc(n * sizeof(int));
    bool* used = (bool*)calloc(n, sizeof(bool));
    
    for (int i = 0; i < n; i++) {
        arr[i] = i;
    }
    
    int count = 0;
    generatePermutations(arr, current, used, 0, n, &count);
    
    free(arr);
    free(current);
    free(used);
    
    return count;
}

int main() {
    int n;
    scanf("%d", &n);
    printf("%d\n", totalNQueens(n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n!)

We generate all n! permutations and check each one for diagonal conflicts in O(n) time

⚠ Quadratic Growth

Space Complexity

O(n)

Space for storing the current permutation and recursion stack

⚡ Linearithmic Space

87.5K Views

Medium Frequency

~25 min Avg. Time

2.9K 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

Brute Force (Generate All Permutations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler