Check if There is a Path With Equal Number of 0's And 1's

Check if There is a Path With Equal Number of 0's And 1's - Problem

You're given a binary matrix grid of size m × n containing only 0's and 1's. Starting from the top-left corner (0, 0), you need to reach the bottom-right corner (m-1, n-1).

Movement Rules: You can only move right or down - that is, from cell (row, col) you can go to either (row + 1, col) or (row, col + 1).

Goal: Determine if there exists a path from start to destination that visits exactly the same number of 0's and 1's.

Example: In a 2×2 grid [[0,1],[1,0]], one valid path is (0,0)→(0,1)→(1,1) visiting [0,1,0], which has equal counts of 0's and 1's.

Input & Output

example_1.py — Basic 2x2 Grid

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

› Output: true

💡 Note: Path (0,0)→(0,1)→(1,1) visits [0,1,0], which has 2 zeros and 1 one. Path (0,0)→(1,0)→(1,1) visits [0,1,0], which also has 2 zeros and 1 one. Neither path has equal counts, so the answer should actually be false for this example.

example_2.py — Balanced Path Exists

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

› Output: true

💡 Note: Path (0,0)→(0,1)→(1,1) visits [0,1,1], which has 1 zero and 2 ones. Path (0,0)→(1,0)→(1,1) visits [0,0,1], which has 2 zeros and 1 one. The second path has equal counts of 0s and 1s.

example_3.py — Single Cell

$ Input: grid = [[1]]

› Output: false

💡 Note: Only one cell exists with value 1, so we have 1 one and 0 zeros, which are not equal.

Visualization

Tap to expand

Understanding the Visualization

Initialize

Start with balance based on first cell value

Propagate

Each cell updates possible balances and passes them forward

Verify

Check if balance 0 exists at the destination

Key Takeaway

🎯 Key Insight: Track balance (difference) instead of separate counts - this reduces state space while preserving the essential information needed to solve the problem.

Time & Space Complexity

Time Complexity

⏱️

O(m*n*k)

m*n cells, each tracking up to k possible balance states where k ≤ m+n

✓ Linear Growth

Space Complexity

O(m*n*k)

DP table storing sets of possible balances for each cell

⚡ Linearithmic Space

Constraints

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

Asked in

G Google 35 a Amazon 28 ⊞ Microsoft 22 f Meta 18

The optimal approach uses dynamic programming with balance tracking. Instead of counting 0's and 1's separately, we track the balance (1's count - 0's count) at each cell. We propagate all possible balance states from each cell to its right and down neighbors. The answer is true if balance 0 is achievable at the destination, indicating equal counts of 0's and 1's along some path.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming with State Tracking	O(mnk)	O(mnk)	Use DP to track all possible balance states at each cell position

Dynamic Programming with State Tracking — Algorithm Steps

For each cell (i,j), maintain a set of possible balance values
Balance = count of 1's - count of 0's encountered so far
For each cell, update balance based on current cell value
Propagate possible balances to right and down neighbors
At destination, check if balance 0 is achievable

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Balance

Start with balance +1 or -1 based on first cell

Propagate States

Each cell receives and updates balance states from top/left

Check Final States

At destination, verify if balance 0 is achievable

Code -

solution.c — C

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

#define MAX_BALANCE 201
#define OFFSET 100

bool findPath(int grid[][100], int m, int n) {
    // dp[i][j][balance+OFFSET] stores if balance is achievable at (i,j)
    bool dp[100][100][MAX_BALANCE];
    memset(dp, false, sizeof(dp));
    
    // Initialize starting cell
    int initialBalance = grid[0][0] == 1 ? 1 : -1;
    dp[0][0][initialBalance + OFFSET] = true;
    
    // Fill DP table
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            if (i == 0 && j == 0) continue;
            
            int currentVal = grid[i][j] == 1 ? 1 : -1;
            
            // From top cell
            if (i > 0) {
                for (int b = 0; b < MAX_BALANCE; b++) {
                    if (dp[i-1][j][b]) {
                        int newBalance = b - OFFSET + currentVal + OFFSET;
                        if (newBalance >= 0 && newBalance < MAX_BALANCE) {
                            dp[i][j][newBalance] = true;
                        }
                    }
                }
            }
            
            // From left cell
            if (j > 0) {
                for (int b = 0; b < MAX_BALANCE; b++) {
                    if (dp[i][j-1][b]) {
                        int newBalance = b - OFFSET + currentVal + OFFSET;
                        if (newBalance >= 0 && newBalance < MAX_BALANCE) {
                            dp[i][j][newBalance] = true;
                        }
                    }
                }
            }
        }
    }
    
    // Check if balance 0 is achievable at destination
    return dp[m-1][n-1][OFFSET];
}

int main() {
    int grid[100][100] = {{0, 1}, {1, 0}};
    int m = 2, n = 2;
    printf("%s\n", findPath(grid, m, n) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m*n*k)

m*n cells, each tracking up to k possible balance states where k ≤ m+n

✓ Linear Growth

Space Complexity

O(m*n*k)

DP table storing sets of possible balances for each cell

⚡ Linearithmic Space

Constraints

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

28.4K Views

Medium Frequency

~25 min Avg. Time

856 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Dynamic Programming with State Tracking — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler