Minimum Number of Flips to Convert Binary Matrix to Zero Matrix

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

Understanding the Visualization

Initial State

Start with the given binary matrix - this is our initial state

Generate Moves

From current state, we can flip any cell, creating new possible states

BFS Exploration

Use BFS to systematically explore states level by level

Target Found

When we reach the zero matrix state, we've found the minimum flips

Key Takeaway

🎯 Key Insight: Use BFS to explore matrix states systematically - each flip creates a new state, and BFS guarantees we find the minimum number of flips by exploring states level by level until we reach the zero matrix.

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

Approach	Time	Space	Notes
✓ BFS State Space Search (Optimal)	O(2^(m×n) × m × n)	O(2^(m×n))	Use BFS to explore all reachable matrix states efficiently
Brute Force (Try All Combinations)	O(2^(m×n) × m × n)	O(1)	Try every possible combination of cell flips using bit manipulation

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;
}

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);
    int* visited = (int*)calloc(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);
                    free(visited);
                    return current.steps + 1;
                }
                
                if (!visited[nextState]) {
                    visited[nextState] = 1;
                    enqueue(queue, nextState, current.steps + 1);
                }
            }
        }
    }
    
    free(queue->data);
    free(queue);
    free(visited);
    return -1;
}

int main() {
    // Input parsing implementation
    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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

BFS State Space Search (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler