N Queens Problem in DSA C

Mental Model

Place N queens on an NxN chessboard so that no two queens attack each other. We try positions row by row, backtracking when conflicts arise.

Analogy: Imagine seating N guests at N tables in a row, where no two guests can see each other directly across or diagonally. You seat one guest per table and move to the next, changing seats if conflicts happen.

Board (4x4 example):
. . . .
. . . .
. . . .
. . . .

'.' means empty, 'Q' means queen placed.

Dry Run Walkthrough

Input: N=4, find one valid arrangement of 4 queens

Goal: Place 4 queens so none attack each other on a 4x4 board

Step 1: Place queen at row 0, column 0

Q . . .
. . . .
. . . .
. . . .

Why: Start placing queen in first row at first column

Step 2: Row 1: col 0 vertical conflict, col 1 upper-left diag conflict, col 2 safe - place

Q . . .
. . Q .
. . . .
. . . .

Why: col 2 has no vertical or diagonal conflicts with row 0

Step 3: Row 2: all columns conflict (vertical or diagonal), backtrack to row 1

Q . . .
. . . .
. . . .
. . . .

Why: No safe position in row 2, remove queen from row 1 col 2 and try next

Step 4: Backtrack fully from row 0 col 0 branch (no more cols in row 1), place row 0 col 1

. Q . .
. . . .
. . . .
. . . .

Why: Previous branch failed, next column in row 0 is safe

Step 5: Row 1: cols 0-2 conflict, col 3 safe - place

. Q . .
. . . Q
. . . .
. . . .

Why: col 3 safe from row 0 col 1

Step 6: Row 2 col 0 safe (no vertical conflict now) - place

. Q . .
. . . Q
Q . . .
. . . .

Why: col 0 clear of conflicts

Step 7: Row 3 col 2 safe - place, solution found

. Q . .
. . . Q
Q . . .
. . Q .

Why: Last queen placed successfully

Result:

. Q . .
. . . Q
Q . . .
. . Q .

Annotated Code

DSA C

#include <stdio.h>
#include <stdbool.h>
#define N 4

bool isSafe(int board[N][N], int row, int col) {
    for (int i = 0; i < row; i++) {
        if (board[i][col] == 1) return false; // check column
    }
    for (int i = row - 1, j = col - 1; i >= 0 && j >= 0; i--, j--) {
        if (board[i][j] == 1) return false; // check upper left diagonal
    }
    for (int i = row - 1, j = col + 1; i >= 0 && j < N; i--, j++) {
        if (board[i][j] == 1) return false; // check upper right diagonal
    }
    return true;
}

bool solveNQueens(int board[N][N], int row) {
    if (row == N) return true; // all queens placed
    for (int col = 0; col < N; col++) {
        if (isSafe(board, row, col)) {
            board[row][col] = 1; // place queen
            if (solveNQueens(board, row + 1)) return true; // recurse
            board[row][col] = 0; // backtrack
        }
    }
    return false; // no safe position found
}

void printBoard(int board[N][N]) {
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < N; j++) {
            if (board[i][j] == 1) printf("Q ");
            else printf(". ");
        }
        printf("\n");
    }
}

int main() {
    int board[N][N] = {0};
    if (solveNQueens(board, 0)) {
        printBoard(board);
    } else {
        printf("No solution found\n");
    }
    return 0;
}

for (int col = 0; col < N; col++) {

try each column in current row to place queen

if (isSafe(board, row, col)) {

check if placing queen here causes no conflicts

board[row][col] = 1; // place queen

place queen tentatively

if (solveNQueens(board, row + 1)) return true;

recurse to next row to place next queen

board[row][col] = 0; // backtrack

remove queen if no solution found ahead

if (row == N) return true;

all queens placed successfully

Output

. Q . . 

. . . Q 

Q . . . 

. . Q . 

Complexity Analysis

Time: O(N!) because each row tries all columns and backtracks on conflicts

Space: O(N^2) for the board storage and O(N) recursion stack for rows

vs Alternative: Brute force tries all board positions (O(2^(N^2))) which is much slower

Edge Cases

N=1 (smallest board)

Places single queen successfully without conflicts

DSA C

if (row == N) return true;

No solution (e.g., N=2 or N=3)

Backtracks fully and prints 'No solution found'

DSA C

return false; // no safe position found

Empty board initialization

Board starts with all zeros, no queens placed

DSA C

int board[N][N] = {0};

When to Use This Pattern

When asked to place items on a grid with constraints and no conflicts, use backtracking to try options row by row and backtrack on conflicts.

Common Mistakes

Mistake: Not checking diagonals for conflicts
Fix: Add checks for upper left and upper right diagonals in isSafe function

Mistake: Not backtracking properly by resetting board cell
Fix: Set board[row][col] back to 0 if recursion fails

Summary

Find a way to place N queens on an NxN board so none attack each other.

Use backtracking when you need to explore all safe placements with constraints.

Try placing queens row by row, backtrack when no safe spot is found in a row.

Practice

1. What is the main goal of the N Queens Problem?

easy

A. Place N queens on an NxN chessboard so that all queens attack each other

B. Find the shortest path for a queen to move across the board

C. Count the total number of queens on the board

D. Place N queens on an NxN chessboard so that no two queens attack each other

Solution

1. Step 1: Understand the problem statement

   The N Queens Problem requires placing N queens on an NxN chessboard so that no two queens threaten each other.

2. Step 2: Identify the correct goal

   This means no two queens share the same row, column, or diagonal.

3. Final Answer:

   Place N queens on an NxN chessboard so that no two queens attack each other -> Option D

4. Quick Check:

   Goal = Place queens safely [OK]

Hint: Remember: Queens must not attack each other [OK]

Common Mistakes:

• Thinking queens can attack each other
• Confusing the problem with counting queens
• Ignoring diagonal attacks

2. Which of the following is the correct way to declare a 2D array for the chessboard in C for the N Queens Problem with size N?

easy

A. int board[];

B. int board[N][N];

C. int board[N];

D. int board(N,N);

Solution

1. Step 1: Recall C syntax for 2D arrays

   In C, a 2D array is declared as type name[size1][size2]; where both sizes are specified.

2. Step 2: Match the correct declaration

   int board[N][N]; uses int board[N][N]; which correctly declares a 2D array for the chessboard.

3. Final Answer:

   int board[N][N]; -> Option B

4. Quick Check:

   2D array syntax = int board[N][N]; [OK]

Hint: Use int board[N][N] for 2D arrays in C [OK]

Common Mistakes:

• Using 1D array for 2D board
• Incorrect syntax like int board(N,N);
• Not specifying both dimensions

3. What will be the output of the following code snippet for N=4 when printing the board after placing queens at positions (0,1), (1,3), (2,0), (3,2)?

int board[4][4] = {0};
board[0][1] = 1;
board[1][3] = 1;
board[2][0] = 1;
board[3][2] = 1;
for(int i=0; i<4; i++) {
  for(int j=0; j<4; j++) {
    printf("%d ", board[i][j]);
  }
  printf("\n");
}

medium

A. 0 0 1 0
1 0 0 0
0 1 0 0
0 0 0 1

B. 1 0 0 0
0 1 0 0
0 0 1 0
0 0 0 1

C. 0 1 0 0
0 0 0 1
1 0 0 0
0 0 1 0

D. 0 0 0 1
0 0 1 0
1 0 0 0
0 1 0 0

Solution

1. Step 1: Place queens on the board as per given positions

   Set board[0][1], board[1][3], board[2][0], board[3][2] to 1; others remain 0.

2. Step 2: Print the board row-wise

   Row 0: 0 1 0 0 Row 1: 0 0 0 1 Row 2: 1 0 0 0 Row 3: 0 0 1 0

3. Final Answer:

   0 1 0 0 0 0 0 1 1 0 0 0 0 0 1 0 -> Option C

4. Quick Check:

   Positions match output [OK]

Hint: Map queen positions to 1s in 2D array [OK]

Common Mistakes:

• Mixing row and column indices
• Printing without spaces or newlines
• Incorrect initialization of board

4. Identify the error in this C function snippet for checking if a queen can be placed at board[row][col]:

int isSafe(int board[][N], int row, int col) {
  for(int i=0; i=0 && j>=0; i--, j--) {
    if(board[i][j] == 1) return 0;
  }
  for(int i=row, j=col; i>=0 && j

medium

A. The function assumes N is a global constant but it may not be

B. The function incorrectly checks columns beyond the current row

C. The function misses checking the lower diagonals

D. The function does not check the current row for queens

Solution

1. Step 1: Analyze the use of N in function parameter

   The function uses int board[][N] but N is not passed as a parameter or defined locally.

2. Step 2: Understand C array parameter rules

   In C, array sizes must be known or passed explicitly; assuming N as global can cause errors if not defined.

3. Final Answer:

   The function assumes N is a global constant but it may not be -> Option A

4. Quick Check:

   Array size N must be known [OK]

Hint: Always pass array size explicitly or define globally [OK]

Common Mistakes:

• Ignoring array size requirements in C
• Assuming N is always global
• Missing checks for diagonals

5. Given the backtracking approach to solve the N Queens Problem, which of the following best describes the role of recursion in the solution?

hard

A. Recursion tries to place queens row by row and backtracks when no safe position is found

B. Recursion counts the total number of queens placed on the board

C. Recursion moves queens randomly until all are placed

D. Recursion only checks if the board is full without placing queens

Solution

1. Step 1: Understand backtracking in N Queens

   Backtracking uses recursion to place queens one row at a time, checking safety.

2. Step 2: Identify recursion behavior

   If no safe position is found in a row, recursion backtracks to previous row to try other positions.

3. Final Answer:

   Recursion tries to place queens row by row and backtracks when no safe position is found -> Option A

4. Quick Check:

   Backtracking = recursive trial and error [OK]

Hint: Think recursion as trial and error with backtracking [OK]

Common Mistakes:

• Thinking recursion places queens randomly
• Confusing recursion with counting
• Ignoring backtracking step