Transform to Chessboard

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.

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

Visualization

Tap to expand

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

✓ Brute Force (Try All Combinations)

⏱️ Time: O(n! * n! * n²) Space: O(n²)

Try every possible combination of row swaps and column swaps to see if we can create a valid chessboard pattern. For each combination, check if the resulting board alternates between 0s and 1s.

Mathematical Analysis (Optimal)

⏱️ Time: O(n²) Space: O(n)

Analyze the board structure to determine if it can be transformed into a chessboard. A valid transformation exists only if there are exactly 2 unique row patterns and 2 unique column patterns, where each pair are complements of each other.

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 <string.h>
#include <math.h>

static char row_patterns[1000][1000];
static int row_counts[1000];
static char col_patterns[1000][1000];
static int col_counts[1000];

int count_mismatches(int** board, int n, int is_row, int pattern_first, 
                    char row_patterns[][1000], int* row_counts,
                    char col_patterns[][1000], int* col_counts) {
    int mismatches = 0;
    if (is_row) {
        char* target_pattern = pattern_first ? row_patterns[0] : row_patterns[1];
        for (int i = 0; i < n; i++) {
            char current_row[1000];
            strcpy(current_row, "");
            for (int j = 0; j < n; j++) {
                char digit[2];
                sprintf(digit, "%d", board[i][j]);
                strcat(current_row, digit);
            }
            char* expected_pattern = (i % 2 == 0) ? target_pattern : (pattern_first ? row_patterns[1] : row_patterns[0]);
            if (strcmp(current_row, expected_pattern) != 0) {
                mismatches++;
            }
        }
    } else {
        char* target_pattern = pattern_first ? col_patterns[0] : col_patterns[1];
        for (int j = 0; j < n; j++) {
            char current_col[1000];
            strcpy(current_col, "");
            for (int i = 0; i < n; i++) {
                char digit[2];
                sprintf(digit, "%d", board[i][j]);
                strcat(current_col, digit);
            }
            char* expected_pattern = (j % 2 == 0) ? target_pattern : (pattern_first ? col_patterns[1] : col_patterns[0]);
            if (strcmp(current_col, expected_pattern) != 0) {
                mismatches++;
            }
        }
    }
    return mismatches / 2;
}

int movesToChessboard(int** board, int boardSize, int* boardColSize) {
    int n = boardSize;
    
    // First check: fundamental chessboard constraint
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            if ((board[i][j] ^ board[i][0] ^ board[0][j] ^ board[0][0]) != 0) {
                return -1;
            }
        }
    }
    
    // Check row patterns - store as strings for comparison
    int num_row_patterns = 0;
    
    for (int i = 0; i < n; i++) {
        char row_str[1000];
        strcpy(row_str, "");
        for (int j = 0; j < n; j++) {
            char digit[2];
            sprintf(digit, "%d", board[i][j]);
            strcat(row_str, digit);
        }
        
        // Find if this pattern exists
        int found = -1;
        for (int p = 0; p < num_row_patterns; p++) {
            if (strcmp(row_patterns[p], row_str) == 0) {
                found = p;
                break;
            }
        }
        
        if (found >= 0) {
            row_counts[found]++;
        } else {
            strcpy(row_patterns[num_row_patterns], row_str);
            row_counts[num_row_patterns] = 1;
            num_row_patterns++;
        }
    }
    
    if (num_row_patterns != 2) {
        return -1;
    }
    
    // Check if patterns are complements
    for (int i = 0; i < n; i++) {
        int val1 = row_patterns[0][i] - '0';
        int val2 = row_patterns[1][i] - '0';
        if (val1 + val2 != 1) {
            return -1;
        }
    }
    
    // Check pattern counts
    int count1 = row_counts[0];
    int count2 = row_counts[1];
    if (abs(count1 - count2) > 1) {
        return -1;
    }
    
    // Check columns
    int num_col_patterns = 0;
    
    for (int j = 0; j < n; j++) {
        char col_str[1000];
        strcpy(col_str, "");
        for (int i = 0; i < n; i++) {
            char digit[2];
            sprintf(digit, "%d", board[i][j]);
            strcat(col_str, digit);
        }
        
        // Find if this pattern exists
        int found = -1;
        for (int p = 0; p < num_col_patterns; p++) {
            if (strcmp(col_patterns[p], col_str) == 0) {
                found = p;
                break;
            }
        }
        
        if (found >= 0) {
            col_counts[found]++;
        } else {
            strcpy(col_patterns[num_col_patterns], col_str);
            col_counts[num_col_patterns] = 1;
            num_col_patterns++;
        }
    }
    
    if (num_col_patterns != 2) {
        return -1;
    }
    
    // Check if column patterns are complements
    for (int i = 0; i < n; i++) {
        int val1 = col_patterns[0][i] - '0';
        int val2 = col_patterns[1][i] - '0';
        if (val1 + val2 != 1) {
            return -1;
        }
    }
    
    int col_count1 = col_counts[0];
    int col_count2 = col_counts[1];
    if (abs(col_count1 - col_count2) > 1) {
        return -1;
    }
    
    // Calculate row swaps
    int row_swaps;
    if (n % 2 == 1) {
        if (count1 > count2) {
            row_swaps = count_mismatches(board, n, 1, 1, row_patterns, row_counts, col_patterns, col_counts);
        } else {
            row_swaps = count_mismatches(board, n, 1, 0, row_patterns, row_counts, col_patterns, col_counts);
        }
    } else {
        int swaps1 = count_mismatches(board, n, 1, 1, row_patterns, row_counts, col_patterns, col_counts);
        int swaps2 = count_mismatches(board, n, 1, 0, row_patterns, row_counts, col_patterns, col_counts);
        row_swaps = (swaps1 < swaps2) ? swaps1 : swaps2;
    }
    
    // Calculate column swaps
    int col_swaps;
    if (n % 2 == 1) {
        if (col_count1 > col_count2) {
            col_swaps = count_mismatches(board, n, 0, 1, row_patterns, row_counts, col_patterns, col_counts);
        } else {
            col_swaps = count_mismatches(board, n, 0, 0, row_patterns, row_counts, col_patterns, col_counts);
        }
    } else {
        int swaps1 = count_mismatches(board, n, 0, 1, row_patterns, row_counts, col_patterns, col_counts);
        int swaps2 = count_mismatches(board, n, 0, 0, row_patterns, row_counts, col_patterns, col_counts);
        col_swaps = (swaps1 < swaps2) ? swaps1 : swaps2;
    }
    
    return row_swaps + col_swaps;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse the 2D array directly
    int** board = NULL;
    int boardSize = 0;
    int* boardColSize = NULL;
    
    // Count rows first
    char* temp = strdup(line);
    char* p = temp;
    while (*p) {
        if (*p == '[' && *(p+1) != '[') {
            boardSize++;
        }
        p++;
    }
    
    // Allocate memory
    board = (int**)malloc(boardSize * sizeof(int*));
    boardColSize = (int*)malloc(boardSize * sizeof(int));
    
    // Parse each row
    p = temp;
    int row = 0;
    while (*p && row < boardSize) {
        if (*p == '[' && *(p+1) != '[') {
            // Find end of this row
            char* row_end = strchr(p, ']');
            if (row_end) {
                *row_end = '\0';
                
                // Count elements in this row
                int col_count = 0;
                char* row_p = p + 1;
                while (*row_p) {
                    if (*row_p >= '0' && *row_p <= '9') {
                        col_count++;
                        while (*row_p >= '0' && *row_p <= '9') row_p++;
                    } else {
                        row_p++;
                    }
                }
                
                board[row] = (int*)malloc(col_count * sizeof(int));
                boardColSize[row] = col_count;
                
                // Parse elements
                parseArray(p, board[row], &boardColSize[row]);
                
                p = row_end + 1;
                row++;
            }
        } else {
            p++;
        }
    }
    
    printf("%d\n", movesToChessboard(board, boardSize, boardColSize));
    
    // Free memory
    for (int i = 0; i < boardSize; i++) {
        free(board[i]);
    }
    free(board);
    free(boardColSize);
    free(temp);
    
    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

⚡ Linearithmic Space

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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Try All Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler