# Minimum number of flips required such that a Binary Matrix doesn’t contain any path from the top left to the bottom right consisting only of 0s

• Last Updated : 28 May, 2022

Given a binary matrix mat[][] of dimensions N*M, the task is to find the minimum number of flips required from the given binary matrix such that there doesn’t exist any path from the top-left cell to the bottom-right cell consisting of only 0s.

Examples:

Input: mat[][] = {{0, 1, 0, 0}, {0, 1, 0, 0}, {0, 1, 0, 0}, {0, 0, 0, 0}}
Output: 1
Explanation:
Operation 1: Flipping the cell at (1, 0) modifies the given matrix to:
0 1 0 0
1 1 0 0
0 1 0 0
0 0 0 0
After the above operations, there doesn’t exists any path from the top-left cell (0, 0) to the bottom-right cell (3, 3) consisting of only 0s. Therefore, the total number of flips required is 1.

Input: mat[][] = {{0, 0, 0, 0}, {0, 0, 0, 0}}
Output: 2

Approach: The given problem can be solved using the DFS Traversal on the given matrix and based on the observation that there exists only at most 2 flipping of nodes such that there doesn’t exist any path from the top-left cell to the bottom-right cell consisting of only 0s. The idea is to perform the DFS traversal from the top-left cell to the bottom-right cell to flip at most one path and print the number of successful DFS calls as the result. Follow the steps below to solve the problem:

• Initialize a function, say DFS(mat, i, j, N, M) that takes the current cell, the given matrix, and its size as the parameter and perform the following steps:
• If the current cell reaches the cell (N – 1, M – 1) then return true.
• Update the value of the cell at (i, j) to 1.
• Recursively call the DFS function in all the four directions of the current cell i.e., (i + 1, j), (i, j + 1), (i – 1, j), and (i, j – 1) if they exists.
• If the DFS Call from the cell (0, 0) returns false, then there exists no such path from the top-left to the bottom-right cell consisting of 0s. Therefore print 0 as the result and return from the function.
• Again if the DFS Call from the cell (0, 0) returns false, then there exists only one path from the top-left to the bottom-right cell consisting of 0s. Therefore print 1 as the result and return from the function.
• Otherwise, print 2 as the result.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include "bits/stdc++.h"``using` `namespace` `std;` `// The four direction coordinates changes``// from the current cell``int` `direction[] = { { -1, 0 }, { 0, 1 },``                       ``{ 0, -1 }, { 1, 0 } };` `// Function that returns true if there``// exists any path from the top-left to``// the bottom-right cell of 0s``bool` `dfs(vector >& matrix,``         ``int` `i, ``int` `j, ``int` `N, ``int` `M)``{` `    ``// If the bottom-right cell is``    ``// reached``    ``if` `(i == N - 1 and j == M - 1) {``        ``return` `true``;``    ``}` `    ``// Update the cell to 1``    ``matrix[i][j] = 1;` `    ``// Traverse in all four directions``    ``for` `(``int` `k = 0; k < 4; k++) {` `        ``// Find the new coordinates``        ``int` `newX = i + direction[k];``        ``int` `newY = j + direction[k];` `        ``// If the new cell is valid``        ``if` `(newX >= 0 and newX < N``            ``and newY >= 0 and newY < M``            ``and matrix[newX][newY] == 0) {` `            ``// Recursively call DFS``            ``if` `(dfs(matrix, newX,``                    ``newY, N, M)) {` `                ``// If path exists, then``                ``// return true``                ``return` `true``;``            ``}``        ``}``    ``}` `    ``// Return false, if there doesn't``    ``// exists any such path``    ``return` `false``;``}` `// Function to flip the minimum number``// of cells such that there doesn't``// exists any such path from (0, 0) to``// (N - 1, M - 1) cell consisting of 0s``int` `solve(vector >& matrix)``{` `    ``int` `N = matrix.size();``    ``int` `M = matrix.size();` `    ``// Case 1: If no such path exists``    ``// already``    ``if` `(!dfs(matrix, 0, 0, N, M)) {``        ``return` `0;``    ``}` `    ``// Case 2: If there exists only``    ``// one path``    ``if` `(!dfs(matrix, 0, 0, N, M)) {``        ``return` `1;``    ``}` `    ``// Case 3: If there exists two-path``    ``return` `2;``}` `// Driver Code``int` `main()``{``    ``vector > mat = {``        ``{ 0, 1, 0, 0 },``        ``{ 0, 1, 0, 0 },``        ``{ 0, 0, 0, 0 }``    ``};``    ``cout << solve(mat);` `    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.io.*;` `class` `GFG{``    ` `// The four direction coordinates changes``// from the current cell``static` `int``[][] direction = { { -``1``, ``0` `}, { ``0``, ``1` `},``                             ``{ ``0``, -``1` `}, { ``1``, ``0` `} };` `// Function that returns true if there``// exists any path from the top-left to``// the bottom-right cell of 0s``static` `boolean` `dfs(``int` `matrix[][], ``int` `i, ``int` `j,``                   ``int` `N, ``int` `M)``{``    ` `    ``// If the bottom-right cell is``    ``// reached``    ``if` `(i == N - ``1` `&& j == M - ``1``)``    ``{``        ``return` `true``;``    ``}` `    ``// Update the cell to 1``    ``matrix[i][j] = ``1``;` `    ``// Traverse in all four directions``    ``for``(``int` `k = ``0``; k < ``4``; k++)``    ``{``        ` `        ``// Find the new coordinates``        ``int` `newX = i + direction[k][``0``];``        ``int` `newY = j + direction[k][``1``];` `        ``// If the new cell is valid``        ``if` `(newX >= ``0` `&& newX < N && newY >= ``0` `&&``            ``newY < M && matrix[newX][newY] == ``0``)``        ``{``            ` `            ``// Recursively call DFS``            ``if` `(dfs(matrix, newX, newY, N, M))``            ``{``                ` `                ``// If path exists, then``                ``// return true``                ``return` `true``;``            ``}``        ``}``    ``}` `    ``// Return false, if there doesn't``    ``// exists any such path``    ``return` `false``;``}` `// Function to flip the minimum number``// of cells such that there doesn't``// exists any such path from (0, 0) to``// (N - 1, M - 1) cell consisting of 0s``static` `int` `solve(``int``[][] matrix)``{``    ``int` `N = matrix.length;``    ``int` `M = matrix[``0``].length;` `    ``// Case 1: If no such path exists``    ``// already``    ``if` `(!dfs(matrix, ``0``, ``0``, N, M))``    ``{``        ``return` `0``;``    ``}` `    ``// Case 2: If there exists only``    ``// one path``    ``if` `(!dfs(matrix, ``0``, ``0``, N, M))``    ``{``        ``return` `1``;``    ``}` `    ``// Case 3: If there exists two-path``    ``return` `2``;``}` `// Driver code``public` `static` `void` `main(String[] args)``{``    ``int``[][] mat = { { ``0``, ``1``, ``0``, ``0` `},``                    ``{ ``0``, ``1``, ``0``, ``0` `},``                    ``{ ``0``, ``0``, ``0``, ``0` `} };` `    ``System.out.println(solve(mat));``}``}` `// This code is contributed by MuskanKalra1`

## Python3

 `# Python3 program for the above approach` `# The four direction coordinates changes``# from the current cell``direction ``=` `[ [ ``-``1``, ``0` `], [ ``0``, ``1` `],``              ``[ ``0``, ``-``1` `],[ ``1``, ``0` `] ]` `# Function that returns true if there``# exists any path from the top-left to``# the bottom-right cell of 0s``def` `dfs(i, j, N, M):``    ` `    ``global` `matrix` `    ``# If the bottom-right cell is``    ``# reached``    ``if` `(i ``=``=` `N ``-` `1` `and` `j ``=``=` `M ``-` `1``):``        ``return` `True` `    ``# Update the cell to 1``    ``matrix[i][j] ``=` `1` `    ``# Traverse in all four directions``    ``for` `k ``in` `range``(``4``):``        ` `        ``# Find the new coordinates``        ``newX ``=` `i ``+` `direction[k][``0``]``        ``newY ``=` `j ``+` `direction[k][``1``]` `        ``# If the new cell is valid``        ``if` `(newX >``=` `0` `and` `newX < N ``and``            ``newY >``=` `0` `and` `newY < M ``and``            ``matrix[newX][newY] ``=``=` `0``):``                ` `            ``# Recursively call DFS``            ``if` `(dfs(newX, newY, N, M)):``                ` `                ``# If path exists, then``                ``# return true``                ``return` `True` `    ``# Return false, if there doesn't``    ``# exists any such path``    ``return` `False` `# Function to flip the minimum number``# of cells such that there doesn't``# exists any such path from (0, 0) to``# (N - 1, M - 1) cell consisting of 0s``def` `solve():``    ` `    ``global` `matrix``    ``N ``=` `len``(matrix)``    ``M ``=` `len``(matrix[``0``])` `    ``# Case 1: If no such path exists``    ``# already``    ``if` `(``not` `dfs(``0``, ``0``, N, M)):``        ``return` `0` `    ``# Case 2: If there exists only``    ``# one path``    ``if` `(``not` `dfs(``0``, ``0``, N, M)):``        ``return` `1` `    ``# Case 3: If there exists two-path``    ``return` `2` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ` `    ``matrix ``=` `[ [ ``0``, ``1``, ``0``, ``0` `],``               ``[ ``0``, ``1``, ``0``, ``0` `],``               ``[ ``0``, ``0``, ``0``, ``0` `] ]``               ` `    ``print``(solve())` `# This code is contributed by mohit kumar 29`

## C#

 `// C# program for the above approach``using` `System;` `class` `GFG{``    ` `// The four direction coordinates changes``// from the current cell``static` `int``[,] direction = { { -1, 0 }, { 0, 1 },``                            ``{ 0, -1 }, { 1, 0 } };` `// Function that returns true if there``// exists any path from the top-left to``// the bottom-right cell of 0s``static` `bool` `dfs(``int` `[,]matrix, ``int` `i, ``int` `j,``                ``int` `N, ``int` `M)``{``    ` `    ``// If the bottom-right cell is``    ``// reached``    ``if` `(i == N - 1 && j == M - 1)``    ``{``        ``return` `true``;``    ``}` `    ``// Update the cell to 1``    ``matrix[i, j] = 1;` `    ``// Traverse in all four directions``    ``for``(``int` `k = 0; k < 4; k++)``    ``{``        ` `        ``// Find the new coordinates``        ``int` `newX = i + direction[k, 0];``        ``int` `newY = j + direction[k, 1];` `        ``// If the new cell is valid``        ``if` `(newX >= 0 && newX < N && newY >= 0 &&``            ``newY < M && matrix[newX, newY] == 0)``        ``{``            ` `            ``// Recursively call DFS``            ``if` `(dfs(matrix, newX, newY, N, M))``            ``{``                ` `                ``// If path exists, then``                ``// return true``                ``return` `true``;``            ``}``        ``}``    ``}` `    ``// Return false, if there doesn't``    ``// exists any such path``    ``return` `false``;``}` `// Function to flip the minimum number``// of cells such that there doesn't``// exists any such path from (0, 0) to``// (N - 1, M - 1) cell consisting of 0s``static` `int` `solve(``int``[,] matrix)``{``    ``int` `N = matrix.GetLength(0);``    ``int` `M = matrix.GetLength(1);` `    ``// Case 1: If no such path exists``    ``// already``    ``if` `(!dfs(matrix, 0, 0, N, M))``    ``{``        ``return` `0;``    ``}` `    ``// Case 2: If there exists only``    ``// one path``    ``if` `(!dfs(matrix, 0, 0, N, M))``    ``{``        ``return` `1;``    ``}` `    ``// Case 3: If there exists two-path``    ``return` `2;``}` `// Driver code``public` `static` `void` `Main(String[] args)``{``    ``int``[,] mat = { { 0, 1, 0, 0 },``                   ``{ 0, 1, 0, 0 },``                   ``{ 0, 0, 0, 0 } };` `    ``Console.WriteLine(solve(mat));``}``}` `// This code is contributed by gauravrajput1`

## Javascript

 ``

Output:

`1`

Time Complexity: O(N + M), as we are using loops traverse N and M times (separately).
Auxiliary Space: O(1), as we are not using any extra space.

My Personal Notes arrow_drop_up