Minimum Number of Flips to Convert Binary Matrix to Zero Matrix - Problem

You are given an m x n binary matrix where each cell is either 0 or 1. Your goal is to transform this entire matrix into a zero matrix (all cells equal to 0) using the minimum number of flip operations.

What is a flip operation? When you flip a cell at position (i, j), you toggle:

The cell itself: 0 → 1 or 1 → 0
All four adjacent neighbors (up, down, left, right) that exist within the matrix bounds

For example, flipping the center cell of a 3x3 matrix would affect the center cell plus its 4 neighbors in a cross pattern.

Challenge: Find the minimum number of flips needed to make all cells 0, or return -1 if it's impossible.

This is like playing a lights-out puzzle where pressing a button affects multiple lights at once!

Input & Output

example_1.py — Basic 2x2 Matrix

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

› Output: 3

💡 Note: One optimal solution: flip (1,0) then (0,0) then (1,1). After first flip: [[1,0],[1,1]], after second flip: [[0,0],[0,1]], after third flip: [[0,0],[0,0]].

example_2.py — Already Zero Matrix

$ Input: mat = [[0,0],[0,0]]

› Output: 0

💡 Note: The matrix is already all zeros, so no flips are needed.

example_3.py — Impossible Case

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

› Output: -1

💡 Note: It's impossible to make this matrix all zeros no matter how many flips we perform, so return -1.

Constraints

m == mat.length
n == mat[0].length
1 <= m, n <= 3
mat[i][j] is either 0 or 1

Visualization

Tap to expand

Asked in

G Google 45 f Facebook 32 a Amazon 28 ⊞ Microsoft 19

This problem requires finding the minimum flips to convert a binary matrix to zero. The optimal approach uses BFS to explore all possible matrix states, treating each configuration as a node in a graph. Key insights: each cell should be flipped at most once and order doesn't matter. While brute force tries all 2^(m×n) combinations, BFS efficiently finds the shortest path by exploring states level by level, guaranteeing the minimum number of flips.

Common Approaches

✓ BFS State Space Search (Optimal)

⏱️ Time: O(2^(m×n) × m × n) Space: O(2^(m×n))

Treat each matrix configuration as a state and use BFS to find the shortest path from initial state to zero matrix. This approach leverages the key insight that each cell should be flipped at most once, and the order doesn't matter.

Brute Force (Try All Combinations)

⏱️ Time: O(2^(m×n) × m × n) Space: O(1)

Generate all possible combinations of flips (2^(m×n) possibilities) and check which one results in a zero matrix with minimum flips. Each combination is represented as a bitmask where bit i indicates whether cell i should be flipped.

BFS State Space Search (Optimal) — Algorithm Steps

Convert initial matrix to integer representation for efficient storage
Use BFS queue starting from initial state
For each state, generate all possible next states by flipping each cell
Track visited states to avoid cycles
Return the minimum steps when zero state is reached

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Queue

Start with initial matrix state and steps = 0

Generate Neighbors

For current state, try flipping each cell to generate all possible next states

Check Target

If any next state is zero matrix, return steps + 1

Continue BFS

Add unvisited states to queue and continue until solution found

Code -

solution.c — C

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

typedef struct {
    int state;
    int steps;
} QueueNode;

typedef struct {
    QueueNode* data;
    int front, rear, size, capacity;
} Queue;

Queue* createQueue(int capacity) {
    Queue* q = (Queue*)malloc(sizeof(Queue));
    q->data = (QueueNode*)malloc(capacity * sizeof(QueueNode));
    q->front = q->rear = q->size = 0;
    q->capacity = capacity;
    return q;
}

void enqueue(Queue* q, int state, int steps) {
    q->data[q->rear] = (QueueNode){state, steps};
    q->rear = (q->rear + 1) % q->capacity;
    q->size++;
}

QueueNode dequeue(Queue* q) {
    QueueNode node = q->data[q->front];
    q->front = (q->front + 1) % q->capacity;
    q->size--;
    return node;
}

int matrixToInt(int** mat, int m, int n) {
    int result = 0;
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            if (mat[i][j] == 1) {
                result |= (1 << (i * n + j));
            }
        }
    }
    return result;
}

int getNextState(int state, int r, int c, int m, int n) {
    int directions[5][2] = {{0, 0}, {-1, 0}, {1, 0}, {0, -1}, {0, 1}};
    int newState = state;
    for (int i = 0; i < 5; i++) {
        int nr = r + directions[i][0], nc = c + directions[i][1];
        if (nr >= 0 && nr < m && nc >= 0 && nc < n) {
            newState ^= (1 << (nr * n + nc));
        }
    }
    return newState;
}

static int visited[1048576]; // Static allocation for large arrays

int minFlips(int** mat, int matSize, int* matColSize) {
    int m = matSize, n = matColSize[0];
    
    int startState = matrixToInt(mat, m, n);
    if (startState == 0) return 0;
    
    Queue* queue = createQueue(100000);
    memset(visited, 0, (1 << (m * n)) * sizeof(int));
    
    enqueue(queue, startState, 0);
    visited[startState] = 1;
    
    while (queue->size > 0) {
        QueueNode current = dequeue(queue);
        
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                int nextState = getNextState(current.state, i, j, m, n);
                
                if (nextState == 0) {
                    free(queue->data);
                    free(queue);
                    return current.steps + 1;
                }
                
                if (!visited[nextState]) {
                    visited[nextState] = 1;
                    enqueue(queue, nextState, current.steps + 1);
                }
            }
        }
    }
    
    free(queue->data);
    free(queue);
    return -1;
}

int main() {
    char input[1000];
    fgets(input, sizeof(input), stdin);
    
    // Remove newline
    input[strcspn(input, "\n")] = 0;
    
    // Parse matrix from format [[a,b,c],[d,e,f],...]
    // First, collect all numbers
    int numbers[100];
    int numCount = 0;
    
    char* p = input;
    while (*p) {
        if (*p >= '0' && *p <= '9') {
            numbers[numCount] = *p - '0';
            numCount++;
        }
        p++;
    }
    
    // Count rows by counting opening brackets after the first one
    int m = 0;
    p = input;
    int foundFirst = 0;
    while (*p) {
        if (*p == '[') {
            if (!foundFirst) {
                foundFirst = 1; // Skip the outermost opening bracket
            } else {
                m++;
            }
        }
        p++;
    }
    
    // Calculate columns
    int n = numCount / m;
    
    // Allocate matrix
    int** mat = (int**)malloc(m * sizeof(int*));
    int* matColSize = (int*)malloc(m * sizeof(int));
    for (int i = 0; i < m; i++) {
        mat[i] = (int*)malloc(n * sizeof(int));
        matColSize[i] = n;
    }
    
    // Fill matrix with parsed numbers
    int idx = 0;
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            mat[i][j] = numbers[idx++];
        }
    }
    
    int result = minFlips(mat, m, matColSize);
    printf("%d\n", result);
    
    // Free memory
    for (int i = 0; i < m; i++) {
        free(mat[i]);
    }
    free(mat);
    free(matColSize);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^(m×n) × m × n)

In worst case visits all 2^(m×n) states, each requiring O(m×n) to generate neighbors

✓ Linear Growth

Space Complexity

O(2^(m×n))

Queue and visited set can contain up to 2^(m×n) different matrix states

⚡ Linearithmic Space

23.4K Views

Medium Frequency

~25 min Avg. Time

892 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

Minimum Number of Flips to Convert Binary Matrix to Zero Matrix - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

BFS State Space Search (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler