Disconnect Path in a Binary Matrix by at Most One Flip

Disconnect Path in a Binary Matrix by at Most One Flip - Problem

You're given an m × n binary matrix representing a grid where you can only move through cells containing 1. Your goal is to determine if you can disconnect the path from the top-left corner (0, 0) to the bottom-right corner (m-1, n-1) by flipping at most one cell.

Movement Rules:

From cell (row, col), you can move to (row + 1, col) or (row, col + 1)
You can only move to cells with value 1

Flipping Rules:

You can flip at most one cell (changing 0→1 or 1→0)
You cannot flip the start (0, 0) or end (m-1, n-1) cells

Return true if you can make the matrix disconnected, false otherwise.

Input & Output

example_1.py — Basic disconnectable grid

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

› Output: true

💡 Note: We can flip grid[1][0] from 1 to 0, making it impossible to reach from (0,0) to (2,2). The path through (1,0) is the only way to connect the regions.

example_2.py — Multiple paths available

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

› Output: false

💡 Note: There are multiple independent paths from (0,0) to (2,2). Even if we flip one cell, alternative routes still exist, so we cannot disconnect the grid with just one flip.

example_3.py — Already disconnected

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

› Output: true

💡 Note: The grid is already disconnected - there's no path from (0,0) to (2,2). Since we can achieve disconnection without any flips, the answer is true.

Constraints

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

Visualization

Tap to expand

Asked in

G Google 12 a Amazon 8 f Meta 6 ⊞ Microsoft 4

The optimal approach uses the max-flow min-cut theorem to determine if the minimum cut between source and sink is at most 1. If the maximum flow from (0,0) to (m-1,n-1) is ≤ 1, then removing one edge can disconnect the path. This avoids the brute force approach of testing every possible flip.

Common Approaches

✓ Max Flow Minimum Cut

⏱️ Time: O(mn(m+n)) Space: O(mn)

Model the problem as a network flow where we need to find if the minimum cut between (0,0) and (m-1,n-1) is at most 1. If the max flow is ≤ 1, then cutting one edge can disconnect the path.

Max Flow Minimum Cut — Algorithm Steps

Build a flow network from the grid
Set (0,0) as source and (m-1,n-1) as sink
Each cell becomes a node, edges have capacity 1
Run max flow algorithm (Ford-Fulkerson or Edmonds-Karp)
If max flow ≤ 1, then minimum cut ≤ 1, so return true
Otherwise return false

Visualization

Tap to expand

Step-by-Step Walkthrough

Graph Construction

Convert grid to flow network with capacity 1 edges

Flow Augmentation

Find augmenting paths from source to sink

Residual Update

Update residual graph after each flow augmentation

Min Cut Analysis

If max flow ≤ 1, then min cut ≤ 1

Code -

solution.c — C

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

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

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

void enqueue(Queue* q, int r, int c) {
    q->data[q->rear++] = r;
    q->data[q->rear++] = c;
}

bool dequeue(Queue* q, int* r, int* c) {
    if (q->front >= q->rear) return false;
    *r = q->data[q->front++];
    *c = q->data[q->front++];
    return true;
}

bool isEmpty(Queue* q) {
    return q->front >= q->rear;
}

bool canReach(int** grid, int m, int n, int startR, int startC, int endR, int endC) {
    if (grid[startR][startC] == 0 || grid[endR][endC] == 0) return false;
    
    bool** visited = (bool**)malloc(m * sizeof(bool*));
    for (int i = 0; i < m; i++) {
        visited[i] = (bool*)calloc(n, sizeof(bool));
    }
    
    Queue* q = createQueue(m * n);
    enqueue(q, startR, startC);
    visited[startR][startC] = true;
    
    int dirs[2][2] = {{0, 1}, {1, 0}};
    int r, c;
    
    while (dequeue(q, &r, &c)) {
        if (r == endR && c == endC) {
            // cleanup
            for (int i = 0; i < m; i++) free(visited[i]);
            free(visited);
            free(q->data);
            free(q);
            return true;
        }
        
        for (int d = 0; d < 2; d++) {
            int nr = r + dirs[d][0], nc = c + dirs[d][1];
            if (nr >= 0 && nr < m && nc >= 0 && nc < n && 
                grid[nr][nc] == 1 && !visited[nr][nc]) {
                visited[nr][nc] = true;
                enqueue(q, nr, nc);
            }
        }
    }
    
    // cleanup
    for (int i = 0; i < m; i++) free(visited[i]);
    free(visited);
    free(q->data);
    free(q);
    return false;
}

bool isPossibleToCutPath(int** grid, int gridSize, int* gridColSize) {
    int m = gridSize, n = gridColSize[0];
    
    // Check if already disconnected
    if (!canReach(grid, m, n, 0, 0, m-1, n-1)) {
        return true;
    }
    
    // Try flipping each cell (except start and end)
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            if ((i == 0 && j == 0) || (i == m-1 && j == n-1)) continue;
            
            // Flip the cell
            grid[i][j] = 1 - grid[i][j];
            
            // Check if path is disconnected after flip
            if (!canReach(grid, m, n, 0, 0, m-1, n-1)) {
                grid[i][j] = 1 - grid[i][j]; // restore
                return true;
            }
            
            // Restore the cell
            grid[i][j] = 1 - grid[i][j];
        }
    }
    
    return false;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Simple parsing - count rows and cols
    int m = 0, n = 0;
    char* ptr = line;
    while (*ptr) {
        if (*ptr == '[' && *(ptr+1) != '[') {
            if (m == 0) {
                // Count elements in first row
                char* temp = ptr + 1;
                n = 1;
                while (*temp && *temp != ']') {
                    if (*temp == ',') n++;
                    temp++;
                }
            }
            m++;
        }
        ptr++;
    }
    
    // Allocate grid
    int** grid = (int**)malloc(m * sizeof(int*));
    int* gridColSize = (int*)malloc(m * sizeof(int));
    for (int i = 0; i < m; i++) {
        grid[i] = (int*)malloc(n * sizeof(int));
        gridColSize[i] = n;
    }
    
    // Parse values
    ptr = line;
    int row = 0, col = 0;
    while (*ptr && row < m) {
        if (*ptr >= '0' && *ptr <= '1') {
            grid[row][col++] = *ptr - '0';
            if (col == n) {
                col = 0;
                row++;
            }
        }
        ptr++;
    }
    
    bool result = isPossibleToCutPath(grid, m, gridColSize);
    printf("%s\n", result ? "true" : "false");
    
    // cleanup
    for (int i = 0; i < m; i++) free(grid[i]);
    free(grid);
    free(gridColSize);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(mn(m+n))

Max flow in grid graph using Edmonds-Karp algorithm

✓ Linear Growth

Space Complexity

O(mn)

Space for flow network representation

⚡ Linearithmic Space

31.3K Views

Medium Frequency

~25 min Avg. Time

876 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

Max Flow Minimum Cut — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler