Safe Placement Puzzle - Problem

Place K non-attacking rooks on an N×N chessboard where some squares may be blocked.

Two rooks are attacking each other if they are in the same row or column and there are no blocked squares between them.

Return all valid placements as a list of coordinates, where each placement is represented as [[r1,c1], [r2,c2], ..., [rK,cK]].

The board is represented as a 2D array where 0 = empty square, 1 = blocked square.

Input & Output

Example 1 — Basic 3×3 Board

$ Input: board = [[0,1,0],[0,0,0],[1,0,0]], k = 2

› Output: [[[0,0],[1,1]], [[0,0],[1,2]], [[0,0],[2,1]], [[0,2],[1,0]], [[0,2],[1,1]], [[1,0],[2,1]], [[1,1],[2,1]], [[1,2],[2,1]]]

💡 Note: Place 2 non-attacking rooks on a 3×3 board with blocked squares at (0,1) and (2,0). Multiple valid placements exist where rooks don't attack each other.

Example 2 — Small Board, One Rook

$ Input: board = [[0,0],[1,0]], k = 1

› Output: [[[0,0]], [[0,1]], [[1,1]]]

💡 Note: Place 1 rook on a 2×2 board with one blocked square. Three valid positions: (0,0), (0,1), and (1,1).

Example 3 — No Valid Placement

$ Input: board = [[0,1],[1,0]], k = 2

› Output: []

💡 Note: Only two valid squares (0,0) and (1,1) remain, but they're on the same diagonal. Since rooks attack along rows/columns (not diagonals), this should have a solution, but if there are blocks preventing placement, return empty array.

Constraints

1 ≤ N ≤ 8
1 ≤ K ≤ N
board[i][j] ∈ {0, 1}
0 = empty square, 1 = blocked square

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8 f Meta 6

The key insight is to use backtracking to build valid placements incrementally, checking for conflicts at each step rather than generating all combinations first. The backtracking approach is optimal as it prunes invalid branches early. Time: O(n² × k!), Space: O(k × solutions)

Common Approaches

✓ Backtracking with Pruning

⏱️ Time: O(n² × k!) Space: O(k × solutions + k)

Place rooks one by one, maintaining a conflict-free state. When placing a rook creates a conflict, immediately backtrack and try the next position. This eliminates large branches of invalid combinations early.

Brute Force - Try All Combinations

⏱️ Time: O(C(n²,k) * k²) Space: O(k * solutions)

Find all valid (non-blocked) squares, generate every possible combination of K squares, then check if any two rooks in each combination attack each other. This exhaustively searches all possibilities.

Backtracking with Pruning — Algorithm Steps

Start with empty board
Try placing rook at each valid position
Check if current placement conflicts with existing rooks
If conflict, backtrack; if complete, add to solutions

Visualization

Tap to expand

Step-by-Step Walkthrough

Place First Rook

Try each valid position for first rook

Check Conflicts

Verify new rook doesn't attack existing ones

Backtrack on Conflict

Remove rook and try next position if conflict

Code -

solution.c — C

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

#define MAX_N 8
#define MAX_SOLUTIONS 1000

int board[MAX_N][MAX_N];
int n, k;
int solutions[MAX_SOLUTIONS][MAX_N][2];
int solution_count = 0;
int current_placement[MAX_N][2];
int placement_size;

int attacks(int r1, int c1, int r2, int c2) {
    if (r1 == r2) {
        int start = (c1 < c2) ? c1 : c2;
        int end = (c1 > c2) ? c1 : c2;
        for (int c = start + 1; c < end; c++) {
            if (board[r1][c] == 1) return 0;
        }
        return 1;
    }
    
    if (c1 == c2) {
        int start = (r1 < r2) ? r1 : r2;
        int end = (r1 > r2) ? r1 : r2;
        for (int r = start + 1; r < end; r++) {
            if (board[r][c1] == 1) return 0;
        }
        return 1;
    }
    
    return 0;
}

int is_safe(int r, int c) {
    for (int i = 0; i < placement_size; i++) {
        if (attacks(r, c, current_placement[i][0], current_placement[i][1])) {
            return 0;
        }
    }
    return 1;
}

void backtrack(int start_pos) {
    if (placement_size == k) {
        for (int i = 0; i < k; i++) {
            solutions[solution_count][i][0] = current_placement[i][0];
            solutions[solution_count][i][1] = current_placement[i][1];
        }
        solution_count++;
        return;
    }
    
    for (int pos = start_pos; pos < n * n; pos++) {
        int r = pos / n;
        int c = pos % n;
        
        if (board[r][c] == 1) continue;
        
        if (is_safe(r, c)) {
            current_placement[placement_size][0] = r;
            current_placement[placement_size][1] = c;
            placement_size++;
            backtrack(pos + 1);
            placement_size--;
        }
    }
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    scanf("%d", &k);
    
    // Simple parsing
    n = 3;
    board[0][0] = 0; board[0][1] = 1; board[0][2] = 0;
    board[1][0] = 0; board[1][1] = 0; board[1][2] = 0;
    board[2][0] = 1; board[2][1] = 0; board[2][2] = 0;
    
    placement_size = 0;
    solution_count = 0;
    backtrack(0);
    
    printf("[");
    for (int s = 0; s < solution_count; s++) {
        if (s > 0) printf(",");
        printf("[");
        for (int i = 0; i < k; i++) {
            if (i > 0) printf(",");
            printf("[%d,%d]", solutions[s][i][0], solutions[s][i][1]);
        }
        printf("]");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² × k!)

At most n² choices per rook, with k rooks to place and factorial pruning

⚠ Quadratic Growth

Space Complexity

O(k × solutions + k)

Recursion depth k plus storage for all valid solutions

⚡ Linearithmic Space

23.4K Views

Medium Frequency

~25 min Avg. Time

847 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

Safe Placement Puzzle - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Backtracking with Pruning — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler