Total coverage of all zeros in a binary matrix

06 Jul, 2022
Given a binary matrix that is, it contains 0s and 1s only, we need to find sum of coverage of all zeros of the matrix where coverage for a particular 0 is defined as total number of ones around a zero in left, right, up and bottom directions. The ones can be anywhere till corner point in a direction. 
Examples: 
Input : mat[][] = {0 0 0 0
                   1 0 0 1
                   0 1 1 0
                   0 1 0 0}
Output : 20
First four zeros are surrounded by only 
one 1.  So coverage for zeros in first 
row is 1 + 1 + 1 + 1
Zeros in second row are surrounded by
three 1's. Note that there is no 1 above.
There are 1's in all other three directions.
Coverage of zeros in second row = 3 + 3. 
Similarly counting for others also, we get
overall count as below.
1 + 1 + 1 + 1 + 3 + 3 + 2 + 2 + 2 + 2 + 2 = 20

Input : mat[][] = {1 1 1 0
                   1 0 0 1}
Output : 8
Coverage of first zero is 2
Coverages of other two zeros is 3
Total coverage = 2 + 3 + 3 = 8
A simple solution to solve this problem is by counting ones around zeros independently i.e. we run loop four times in each direction for each cell for the given matrix. Whenever we find a 1 in any loop, we break the loop and increment result by 1.
An efficient solution is to do following. 
Traverse all rows from left to right, increment result if a 1 is already seen (in current traversal) and current element is 0.Traverse all rows from right to left, increment result if a 1 is already seen (in current traversal) and current element is 0.Traverse all columns from top to bottom, increment result if a 1 is already seen (in current traversal) and current element is 0.Traverse all columns from bottom to top, increment result if a 1 is already seen (in current traversal) and current element is 0.
Traverse all rows from left to right, increment result if a 1 is already seen (in current traversal) and current element is 0.
Traverse all rows from right to left, increment result if a 1 is already seen (in current traversal) and current element is 0.
Traverse all columns from top to bottom, increment result if a 1 is already seen (in current traversal) and current element is 0.
Traverse all columns from bottom to top, increment result if a 1 is already seen (in current traversal) and current element is 0.
In below code a Boolean variable isOne is taken, which is made true as soon as a one is encountered in current traversal, for all zeros after that iteration, result is incremented by one, same procedure is applied in all four directions to get final answer. We reset isOne to false after every traversal.
C++
Java
Python3
C#
Javascript
//  C++ program to get total coverage of all zeros in// a binary matrix#include <bits/stdc++.h>using namespace std;#define R 4#define C 4 // Returns total coverage of all zeros in mat[][]int getTotalCoverageOfMatrix(int mat[R][C]){    int res = 0;     //  looping for all rows of matrix    for (int i = 0; i < R; i++)    {        bool isOne = false;  // 1 is not seen yet         // looping in columns from left to right        // direction to get left ones        for (int j = 0; j < C; j++)        {            // If one is found from left            if (mat[i][j] == 1)                isOne = true;             // If 0 is found and we have found            // a 1 before.            else if (isOne)                res++;        }         // Repeat the above process for right to        // left direction.        isOne = false;        for (int j = C-1; j >= 0; j--)        {            if (mat[i][j] == 1)                isOne = true;            else if (isOne)                res++;        }    }     // Traversing across columns for up and down    // directions.    for (int j = 0; j < C; j++)    {        bool isOne = false;  // 1 is not seen yet        for (int i = 0; i < R; i++)        {            if (mat[i][j] == 1)                isOne = true;            else if (isOne)                res++;        }         isOne = false;        for (int i = R-1; i >= 0; i--)        {            if (mat[i][j] == 1)                isOne = true;            else if (isOne)                res++;        }    }    return res;} //  Driver code to test above methodsint main(){    int mat[R][C] = {{0, 0, 0, 0},        {1, 0, 0, 1},        {0, 1, 1, 0},        {0, 1, 0, 0}    };     cout << getTotalCoverageOfMatrix(mat);     return 0;}
// Java program to get total// coverage of all zeros in// a binary matriximport java .io.*; class GFG{static int R = 4;static int C = 4; // Returns total coverage// of all zeros in mat[][]static int getTotalCoverageOfMatrix(int [][]mat){    int res = 0;     // looping for all    // rows of matrix    for (int i = 0; i < R; i++)    {        // 1 is not seen yet        boolean isOne = false;         // looping in columns from        // left to right direction        // to get left ones        for (int j = 0; j < C; j++)        {            // If one is found            // from left            if (mat[i][j] == 1)                isOne = true;             // If 0 is found and we            // have found a 1 before.            else if (isOne)                res++;        }         // Repeat the above        // process for right        // to left direction.        isOne = false;        for (int j = C - 1; j >= 0; j--)        {            if (mat[i][j] == 1)                isOne = true;            else if (isOne)                res++;        }    }     // Traversing across columns    // for up and down directions.    for (int j = 0; j < C; j++)    {        // 1 is not seen yet        boolean isOne = false;        for (int i = 0; i < R; i++)        {            if (mat[i][j] == 1)                isOne = true;            else if (isOne)                res++;        }         isOne = false;        for (int i = R - 1; i >= 0; i--)        {            if (mat[i][j] == 1)                isOne = true;            else if (isOne)                res++;        }    }    return res;} // Driver codestatic public void main (String[] args){    int [][]mat = {{0, 0, 0, 0},                   {1, 0, 0, 1},                   {0, 1, 1, 0},                   {0, 1, 0, 0}}; System.out.println(           getTotalCoverageOfMatrix(mat));}} // This code is contributed by anuj_67.
# Python3 program to get total coverage of all zeros in# a binary matrixR = 4C = 4 # Returns total coverage of all zeros in mat[][]def getTotalCoverageOfMatrix(mat):    res = 0         # looping for all rows of matrix    for i in range(R):                 isOne = False # 1 is not seen yet                 # looping in columns from left to right        # direction to get left ones        for j in range(C):                         # If one is found from left            if (mat[i][j] == 1):                isOne = True                             # If 0 is found and we have found            # a 1 before.            else if (isOne):                res += 1                     # Repeat the above process for right to        # left direction.        isOne = False        for j in range(C - 1, -1, -1):            if (mat[i][j] == 1):                isOne = True            else if (isOne):                res += 1         # Traversing across columns for up and down    # directions.    for j in range(C):        isOne = False # 1 is not seen yet        for i in range(R):                         if (mat[i][j] == 1):                isOne = True            else if (isOne):                res += 1                 isOne = False        for i in range(R - 1, -1, -1):            if (mat[i][j] == 1):                isOne = True            else if (isOne):                res += 1                     return res # Driver codemat = [[0, 0, 0, 0],[1, 0, 0, 1],[0, 1, 1, 0],[0, 1, 0, 0]]print(getTotalCoverageOfMatrix(mat)) # This code is contributed by shubhamsingh10
// C# program to get total coverage// of all zeros in a binary matrixusing System; class GFG {     static int R = 4;static int C = 4; // Returns total coverage of all zeros in mat[][]static int getTotalCoverageOfMatrix(int [,]mat){    int res = 0;     // looping for all rows of matrix    for (int i = 0; i < R; i++)    {        // 1 is not seen yet        bool isOne = false;         // looping in columns from left to        // right direction to get left ones        for (int j = 0; j < C; j++)        {            // If one is found from left            if (mat[i,j] == 1)                isOne = true;             // If 0 is found and we            // have found a 1 before.            else if (isOne)                res++;        }         // Repeat the above process for        // right to left direction.        isOne = false;        for (int j = C-1; j >= 0; j--)        {            if (mat[i,j] == 1)                isOne = true;            else if (isOne)                res++;        }    }     // Traversing across columns    // for up and down directions.    for (int j = 0; j < C; j++)    {        // 1 is not seen yet        bool isOne = false;        for (int i = 0; i < R; i++)        {            if (mat[i,j] == 1)                isOne = true;            else if (isOne)                res++;        }         isOne = false;        for (int i = R-1; i >= 0; i--)        {            if (mat[i,j] == 1)                isOne = true;            else if (isOne)                res++;        }    }    return res;} // Driver code to test above methods    static public void Main ()    {        int [,]mat = {{0, 0, 0, 0},                      {1, 0, 0, 1},                      {0, 1, 1, 0},                      {0, 1, 0, 0}};     Console.WriteLine(getTotalCoverageOfMatrix(mat));    }} // This code is contributed by vt_m.
<script>    // Javascript program to get total    // coverage of all zeros in    // a binary matrix         let R = 4;    let C = 4;     // Returns total coverage    // of all zeros in mat[][]    function getTotalCoverageOfMatrix(mat)    {        let res = 0;         // looping for all        // rows of matrix        for (let i = 0; i < R; i++)        {            // 1 is not seen yet            let isOne = false;             // looping in columns from            // left to right direction            // to get left ones            for (let j = 0; j < C; j++)            {                // If one is found                // from left                if (mat[i][j] == 1)                    isOne = true;                 // If 0 is found and we                // have found a 1 before.                else if (isOne)                    res++;            }             // Repeat the above            // process for right            // to left direction.            isOne = false;            for (let j = C - 1; j >= 0; j--)            {                if (mat[i][j] == 1)                    isOne = true;                else if (isOne)                    res++;            }        }         // Traversing across columns        // for up and down directions.        for (let j = 0; j < C; j++)        {            // 1 is not seen yet            let isOne = false;            for (let i = 0; i < R; i++)            {                if (mat[i][j] == 1)                    isOne = true;                else if (isOne)                    res++;            }             isOne = false;            for (let i = R - 1; i >= 0; i--)            {                if (mat[i][j] == 1)                    isOne = true;                else if (isOne)                    res++;            }        }        return res;    }         let mat = [[0, 0, 0, 0],               [1, 0, 0, 1],               [0, 1, 1, 0],               [0, 1, 0, 0]];       document.write(getTotalCoverageOfMatrix(mat)); </script>
20
Time Complexity: O(n2) Auxiliary Space: O(1)
This article is contributed by Utkarsh Trivedi. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks. 
vt_m
SHUBHAMSINGH10
decode2207
sweetyty
surinderdawra388
hardikkoriintern
Matrix
Matrix
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Sudoku | Backtracking-7
The Celebrity Problem
Rotate a matrix by 90 degree in clockwise direction without using any extra space
Maximum size square sub-matrix with all 1s
Count all possible paths from top left to bottom right of a mXn matrix
Maximum size rectangle binary sub-matrix with all 1s
Inplace rotate square matrix by 90 degrees | Set 1
Unique paths in a Grid with Obstacles
Printing all solutions in N-Queen Problem
Min Cost Path | DP-6