Transform to Chessboard - Practice Coding Problems

Transform to Chessboard - Problem

Transform to Chessboard

You are given an n x n binary grid board filled with 0s and 1s. Your goal is to transform this board into a valid chessboard pattern using the minimum number of moves.

In each move, you can:
• Swap any two rows with each other
• Swap any two columns with each other

A chessboard pattern is a board where no two adjacent cells (horizontally or vertically) have the same value - just like a real chessboard where black and white squares alternate.

Return: The minimum number of moves needed to create a chessboard pattern, or -1 if it's impossible.

Example:

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

This can be transformed into a chessboard by swapping 2 rows or 2 columns.

Input & Output

example_1.py — Basic Transform

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

› Output: 2

💡 Note: The board has 2 unique row patterns: [0,1,1,0] and [1,0,0,1] which are complements. Same for columns. We can swap row 0 with row 2, and the result will be a valid chessboard pattern. Total moves needed: 2.

example_2.py — Already Valid

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

› Output: 0

💡 Note: This 2x2 board is already a valid chessboard pattern where no adjacent cells have the same value. No moves needed.

example_3.py — Impossible Case

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

› Output: -1

💡 Note: This board cannot be transformed into a chessboard. There are more than 2 unique row patterns, and the patterns are not proper complements of each other.

Visualization

Tap to expand

Understanding the Visualization

Pattern Discovery

Identify all unique row and column patterns in the board

Validity Check

Verify there are exactly 2 patterns for rows and columns, each being complements

Count Analysis

Ensure pattern counts are balanced (differ by at most 1)

Optimal Target

Determine which chessboard arrangement requires fewer swaps

Move Calculation

Count minimum row swaps and column swaps needed

Key Takeaway

🎯 Key Insight: Only boards with exactly 2 complementary patterns for both rows and columns can be transformed into chessboards. The mathematical approach provides O(n²) optimal solution.

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Single pass through the n×n board to analyze patterns

⚠ Quadratic Growth

Space Complexity

O(n)

Space to store unique row and column patterns

⚡ Linearithmic Space

Constraints

n == board.length
n == board[i].length
2 ≤ n ≤ 30
board[i][j] is either 0 or 1
Only boards with exactly 2 complementary patterns can be transformed

Asked in

G Google 15 f Facebook 12 Apple 8 ⊞ Microsoft 6

The optimal solution uses mathematical analysis to determine if transformation is possible. A board can become a chessboard if and only if it has exactly 2 unique row patterns and 2 unique column patterns, where each pair are perfect complements. We then calculate the minimum swaps needed by counting misplaced patterns for both possible target arrangements.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Combinations)	O(n! * n! * n²)	O(n²)	Generate all possible row and column swap combinations until finding a chessboard
Mathematical Analysis (Optimal)	O(n²)	O(n)	Use mathematical properties to determine if transformation is possible and calculate minimum moves

Brute Force (Try All Combinations) — Algorithm Steps

Generate all possible permutations of rows
For each row permutation, generate all column permutations
Check if the resulting board is a valid chessboard
Track minimum moves needed across all valid combinations
Return minimum moves or -1 if no valid chessboard found

Visualization

Tap to expand

Step-by-Step Walkthrough

Original Board

Start with the given board configuration

Generate Row Permutations

Create all possible row arrangements

Generate Column Permutations

For each row arrangement, try all column arrangements

Validate Pattern

Check if result forms a valid chessboard pattern

Count Moves

Calculate minimum swaps needed for valid configurations

Code -

solution.c — C

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

int isChessboard(int** board, int n) {
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            if (board[i][j] != (i + j) % 2) {
                return 0;
            }
        }
    }
    return 1;
}

int countSwaps(int* perm, int n) {
    int swaps = 0;
    int* arr = (int*)malloc(n * sizeof(int));
    for (int i = 0; i < n; i++) arr[i] = perm[i];
    
    for (int i = 0; i < n; i++) {
        if (arr[i] != i) {
            for (int j = i + 1; j < n; j++) {
                if (arr[j] == i) {
                    int temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                    swaps++;
                    break;
                }
            }
        }
    }
    
    free(arr);
    return swaps;
}

// This is a simplified version - full permutation generation needed for complete solution
int movesToChessboard(int** board, int boardSize, int* boardColSize) {
    if (boardSize > 4) return -1; // Too slow for larger boards
    
    // For a complete solution, implement permutation generation
    // This is a placeholder that checks if board is already valid
    if (isChessboard(board, boardSize)) {
        return 0;
    }
    
    return -1; // Simplified - would need full permutation logic
}

int main() {
    // Input parsing and function call would go here
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n! * n! * n²)

n! permutations for rows, n! for columns, n² to validate each board

⚠ Quadratic Growth

Space Complexity

O(n²)

Space to store board copies and permutation arrays

⚠ Quadratic Space

Constraints

n == board.length
n == board[i].length
2 ≤ n ≤ 30
board[i][j] is either 0 or 1
Only boards with exactly 2 complementary patterns can be transformed

31.0K Views

Medium Frequency

~25 min Avg. Time

780 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Try All Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler