Minimum Operations to Remove Adjacent Ones in Matrix

Minimum Operations to Remove Adjacent Ones in Matrix - Problem

You are given a 0-indexed binary matrix grid. In one operation, you can flip any 1 in grid to be 0.

A binary matrix is well-isolated if there is no 1 in the matrix that is 4-directionally connected (i.e., horizontal and vertical) to another 1.

Return the minimum number of operations to make grid well-isolated.

Input & Output

Example 1 — Basic Adjacent 1s

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

› Output: 1

💡 Note: Remove the center 1 at position (1,1). This breaks both adjacencies: (0,0)-(0,1) and (0,1)-(1,1), making the matrix well-isolated with only isolated 1s remaining.

Example 2 — Multiple Groups

$ Input: grid = [[1,1],[1,1]]

› Output: 2

💡 Note: All four 1s are connected. We need to remove at least 2 of them to make remaining 1s non-adjacent. One optimal solution is to keep (0,0) and (1,1) which are diagonally positioned.

Example 3 — Already Well-Isolated

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

› Output: 0

💡 Note: All 1s are already isolated with no adjacent pairs. No operations needed.

Constraints

m == grid.length
n == grid[i].length
1 ≤ m, n ≤ 15
grid[i][j] is either 0 or 1

Visualization

Tap to expand

Asked in

G Google 15 f Meta 12 a Amazon 8

This problem requires finding the minimum number of 1s to remove so that no two 1s are adjacent. The key insight is to model this as a maximum independent set problem on a bipartite graph. Best approach uses bipartite matching with O(V³) time and O(V²) space complexity.

Common Approaches

✓ Brute Force - Try All Combinations

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

Generate all possible subsets of 1s to flip, check if resulting matrix is well-isolated, and return minimum flips needed. This explores every possibility but is extremely slow.

Maximum Independent Set (Bipartite Graph)

⏱️ Time: O(V³) Space: O(V²)

Convert the problem to finding maximum independent set in a bipartite graph. Color cells like a chessboard, where adjacent 1s must be in different colors. Use maximum matching to solve efficiently.

Brute Force - Try All Combinations — Algorithm Steps

Step 1: Find all positions with 1s in the matrix
Step 2: Generate all possible combinations of positions to flip
Step 3: For each combination, check if matrix becomes well-isolated
Step 4: Return minimum number of flips needed

Visualization

Tap to expand

Step-by-Step Walkthrough

Find All 1s

Locate all positions containing 1s in the matrix

Generate Combinations

Try all possible subsets of 1s to flip

Validate

Check if each combination results in well-isolated matrix

Code -

solution.c — C

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

typedef struct {
    int x, y;
} Point;

int isWellIsolated(int** matrix, int m, int n) {
    int directions[4][2] = {{0,1}, {0,-1}, {1,0}, {-1,0}};
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            if (matrix[i][j] == 1) {
                for (int d = 0; d < 4; d++) {
                    int ni = i + directions[d][0];
                    int nj = j + directions[d][1];
                    if (ni >= 0 && ni < m && nj >= 0 && nj < n && matrix[ni][nj] == 1) {
                        return 0;
                    }
                }
            }
        }
    }
    return 1;
}

int backtrack(int** grid, int m, int n, Point* ones, int onesCount, int idx, Point* flipped, int flippedCount) {
    if (idx == onesCount) {
        int** testGrid = (int**)malloc(m * sizeof(int*));
        for (int i = 0; i < m; i++) {
            testGrid[i] = (int*)malloc(n * sizeof(int));
            memcpy(testGrid[i], grid[i], n * sizeof(int));
        }
        
        for (int i = 0; i < flippedCount; i++) {
            testGrid[flipped[i].x][flipped[i].y] = 0;
        }
        
        int result = isWellIsolated(testGrid, m, n) ? flippedCount : INT_MAX;
        
        for (int i = 0; i < m; i++) {
            free(testGrid[i]);
        }
        free(testGrid);
        return result;
    }
    
    int result1 = backtrack(grid, m, n, ones, onesCount, idx + 1, flipped, flippedCount);
    flipped[flippedCount] = ones[idx];
    int result2 = backtrack(grid, m, n, ones, onesCount, idx + 1, flipped, flippedCount + 1);
    return result1 < result2 ? result1 : result2;
}

int solution(int** grid, int m, int n) {
    Point ones[1000];
    int onesCount = 0;
    
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            if (grid[i][j] == 1) {
                ones[onesCount].x = i;
                ones[onesCount].y = j;
                onesCount++;
            }
        }
    }
    
    if (onesCount == 0) return 0;
    
    Point flipped[1000];
    return backtrack(grid, m, n, ones, onesCount, 0, flipped, 0);
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Simple parsing for small test cases
    int grid[10][10];
    int m = 0, n = 0;
    
    // Parse the matrix manually
    char* ptr = line + 1; // Skip first [
    while (*ptr && *ptr != ']') {
        if (*ptr == '[') {
            ptr++;
            n = 0;
            while (*ptr && *ptr != ']') {
                if (*ptr >= '0' && *ptr <= '9') {
                    grid[m][n++] = *ptr - '0';
                }
                ptr++;
            }
            m++;
        }
        ptr++;
    }
    
    int** gridPtr = (int**)malloc(m * sizeof(int*));
    for (int i = 0; i < m; i++) {
        gridPtr[i] = (int*)malloc(n * sizeof(int));
        for (int j = 0; j < n; j++) {
            gridPtr[i][j] = grid[i][j];
        }
    }
    
    printf("%d\n", solution(gridPtr, m, n));
    
    for (int i = 0; i < m; i++) {
        free(gridPtr[i]);
    }
    free(gridPtr);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^k × m × n)

2^k combinations where k is number of 1s, each requiring O(m×n) validation

✓ Linear Growth

Space Complexity

O(m × n)

Space for matrix copy and recursion stack

✓ Linear Space

3.2K Views

Medium Frequency

~35 min Avg. Time

89 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