Chessboard Region Attacker - Problem

Given an N×N chessboard and K bishops, place all K bishops on the board such that no two bishops attack each other diagonally.

Two bishops attack each other if they are on the same diagonal (either main diagonal or anti-diagonal). Your task is to count the total number of valid arrangements where all K bishops can be placed without attacking each other.

Note: Bishops move diagonally any number of squares. A bishop at position (i, j) attacks all positions (i+x, j+x), (i+x, j-x), (i-x, j+x), and (i-x, j-x) where the resulting position is within the board bounds.

Input & Output

Example 1 — Small Board

$ Input: n = 3, k = 2

› Output: 26

💡 Note: On a 3×3 board, we can place 2 non-attacking bishops in 26 different ways. Bishops placed on different colored squares never attack each other.

Example 2 — Single Bishop

$ Input: n = 4, k = 1

› Output: 16

💡 Note: With only 1 bishop on a 4×4 board, we can place it on any of the 16 squares, so there are 16 valid arrangements.

Example 3 — Impossible Case

$ Input: n = 2, k = 5

› Output: 0

💡 Note: On a 2×2 board, we can place at most 2 bishops (one on each color). Placing 5 bishops is impossible.

Constraints

1 ≤ n ≤ 10
0 ≤ k ≤ n²

Visualization

Tap to expand

Asked in

G Google 15 f Facebook 12 M Microsoft 8

The key insight is that bishops on different colored squares never attack each other diagonally. The best approach uses color separation to split the problem into independent subproblems on black and white squares. Time: O(K × 2^(N²/2)), Space: O(N + K)

Common Approaches

✓ Backtracking with Pruning

⏱️ Time: O(N² choose K) Space: O(N + K)

Use recursive backtracking to place bishops sequentially. Track occupied diagonals and immediately backtrack when a conflict is detected, avoiding the need to generate complete invalid arrangements.

Brute Force - Try All Combinations

⏱️ Time: O(C(N²,K) × K²) Space: O(K)

Generate all C(N²,K) combinations of K positions from the N×N board. For each combination, check if any two bishops attack each other by comparing their diagonal positions.

Optimized with Color Separation

⏱️ Time: O(K × 2^(N²/2)) Space: O(N + K)

Utilize the key insight that bishops on black squares can never attack bishops on white squares. Split the problem into placing some bishops on black squares and the rest on white squares, then combine the results.

Backtracking with Pruning — Algorithm Steps

Start with empty board and track occupied diagonals
Try placing bishop at each position
If position conflicts with existing bishops, backtrack immediately
When K bishops placed successfully, increment counter

Visualization

Tap to expand

Step-by-Step Walkthrough

Place

Try placing bishop at current position

Check

Immediately check for diagonal conflicts

Recurse

Continue with next position or backtrack

Code -

solution.c — C

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

int backtrack(int n, int k, int pos, int placed, bool* mainDiag, bool* antiDiag) {
    if (placed == k) return 1;
    
    int count = 0;
    for (int i = pos; i < n * n; i++) {
        int row = i / n;
        int col = i % n;
        int mainD = row - col + n - 1;  // Shift to positive indices
        int antiD = row + col;
        
        if (!mainDiag[mainD] && !antiDiag[antiD]) {
            mainDiag[mainD] = true;
            antiDiag[antiD] = true;
            
            count += backtrack(n, k, i + 1, placed + 1, mainDiag, antiDiag);
            
            mainDiag[mainD] = false;
            antiDiag[antiD] = false;
        }
    }
    return count;
}

int solution(int n, int k) {
    if (k > 2 * n - 2) return 0;
    
    bool mainDiag[2*n] = {false};  // -n+1 to n-1, shifted to 0 to 2n-2
    bool antiDiag[2*n] = {false}; // 0 to 2n-2
    
    return backtrack(n, k, 0, 0, mainDiag, antiDiag);
}

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

Time & Space Complexity

Time Complexity

⏱️

O(N² choose K)

Explores valid placements with early pruning, much better than brute force

✓ Linear Growth

Space Complexity

O(N + K)

Recursion stack depth K plus diagonal tracking arrays of size O(N)

✓ Linear Space

23.4K Views

Medium Frequency

~35 min Avg. Time

890 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

Chessboard Region Attacker - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Backtracking with Pruning — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler