GFG App
Open App
Browser
Continue

# Count zeros in a row wise and column wise sorted matrix

Given a N x N binary matrix (elements in matrix can be either 1 or 0) where each row and column of the matrix is sorted in ascending order, count number of 0s present in it.
Expected time complexity is O(N).

Examples:

```Input:
[0, 0, 0, 0, 1]
[0, 0, 0, 1, 1]
[0, 1, 1, 1, 1]
[1, 1, 1, 1, 1]
[1, 1, 1, 1, 1]

Output: 8

Input:
[0, 0]
[0, 0]

Output: 4

Input:
[1, 1, 1, 1]
[1, 1, 1, 1]
[1, 1, 1, 1]
[1, 1, 1, 1]

Output: 0```

The idea is very simple. We start from the bottom-left corner of the matrix and repeat below steps until we find the top or right edge of the matrix.

1. Decrement row index until we find a 0.
2. Add number of 0s in current column i.e. current row index + 1 to the result and move right to next column (Increment col index by 1).

The above logic will work since the matrix is row-wise and column-wise sorted. The logic will also work for any matrix containing non-negative integers.

Below is the implementation of above idea :

## C++

 `// C++ program to count number of 0s in the given` `// row-wise and column-wise sorted binary matrix.` `#include ` `using` `namespace` `std;` `// define size of square matrix` `#define N 5`   `// Function to count number of 0s in the given` `// row-wise and column-wise sorted binary matrix.` `int` `countZeroes(``int` `mat[N][N])` `{` `    ``// start from bottom-left corner of the matrix` `    ``int` `row = N - 1, col = 0;`   `    ``// stores number of zeroes in the matrix` `    ``int` `count = 0;`   `    ``while` `(col < N)` `    ``{` `        ``// move up until you find a 0` `        ``while` `(mat[row][col])`   `            ``// if zero is not found in current column,` `            ``// we are done` `            ``if` `(--row < 0)` `                ``return` `count;`   `        ``// add 0s present in current column to result` `        ``count += (row + 1);`   `        ``// move right to next column` `        ``col++;` `    ``}`   `    ``return` `count;` `}`   `// Driver Program to test above functions` `int` `main()` `{` `    ``int` `mat[N][N] =` `    ``{` `        ``{ 0, 0, 0, 0, 1 },` `        ``{ 0, 0, 0, 1, 1 },` `        ``{ 0, 1, 1, 1, 1 },` `        ``{ 1, 1, 1, 1, 1 },` `        ``{ 1, 1, 1, 1, 1 }` `    ``};`   `    ``cout << countZeroes(mat);`   `    ``return` `0;` `}`

## C

 `// C program to count number of 0s in the given` `// row-wise and column-wise sorted binary matrix.` `#include `   `// define size of square matrix` `#define N 5`   `// Function to count number of 0s in the given` `// row-wise and column-wise sorted binary matrix.` `int` `countZeroes(``int` `mat[N][N])` `{` `    ``// start from bottom-left corner of the matrix` `    ``int` `row = N - 1, col = 0;`   `    ``// stores number of zeroes in the matrix` `    ``int` `count = 0;`   `    ``while` `(col < N)` `    ``{` `        ``// move up until you find a 0` `        ``while` `(mat[row][col])`   `            ``// if zero is not found in current column,` `            ``// we are done` `            ``if` `(--row < 0)` `                ``return` `count;`   `        ``// add 0s present in current column to result` `        ``count += (row + 1);`   `        ``// move right to next column` `        ``col++;` `    ``}`   `    ``return` `count;` `}`   `// Driver Program to test above functions` `int` `main()` `{` `    ``int` `mat[N][N] =` `    ``{` `        ``{ 0, 0, 0, 0, 1 },` `        ``{ 0, 0, 0, 1, 1 },` `        ``{ 0, 1, 1, 1, 1 },` `        ``{ 1, 1, 1, 1, 1 },` `        ``{ 1, 1, 1, 1, 1 }` `    ``};` `    `  `    ``printf``(``"%d"``,countZeroes(mat));`   `    ``return` `0;` `}`   `// This code is contributed by kothavvsaakash.`

## Java

 `// Java program to count number of 0s in the given` `// row-wise and column-wise sorted binary matrix` `import` `java.io.*;`   `class` `GFG ` `{` `    ``public` `static` `int` `N = ``5``;` `    `  `    ``// Function to count number of 0s in the given` `    ``// row-wise and column-wise sorted binary matrix.` `    ``static` `int` `countZeroes(``int` `mat[][])` `    ``{` `        ``// start from bottom-left corner of the matrix` `        ``int` `row = N - ``1``, col = ``0``;` ` `  `        ``// stores number of zeroes in the matrix` `        ``int` `count = ``0``;` ` `  `        ``while` `(col < N)` `        ``{` `            ``// move up until you find a 0` `            ``while` `(mat[row][col] > ``0``)` ` `  `                ``// if zero is not found in current column,` `                ``// we are done` `                ``if` `(--row < ``0``)` `                    ``return` `count;` ` `  `            ``// add 0s present in current column to result` `            ``count += (row + ``1``);` ` `  `            ``// move right to next column` `            ``col++;` `        ``}` ` `  `        ``return` `count;` `    ``}` `    `  `    ``// Driver program` `    ``public` `static` `void` `main (String[] args) ` `    ``{` `        ``int` `mat[][] = { { ``0``, ``0``, ``0``, ``0``, ``1` `},` `                        ``{ ``0``, ``0``, ``0``, ``1``, ``1` `},` `                        ``{ ``0``, ``1``, ``1``, ``1``, ``1` `},` `                        ``{ ``1``, ``1``, ``1``, ``1``, ``1` `},` `                        ``{ ``1``, ``1``, ``1``, ``1``, ``1` `} };` `        ``System.out.println(countZeroes(mat));` `    ``}` `}`   `// This code is contributed by Pramod Kumar`

## Python

 `# Python program to count number ` `# of 0s in the given row-wise` `# and column-wise sorted ` `# binary matrix.`   `# Function to count number ` `# of 0s in the given` `# row-wise and column-wise` `# sorted binary matrix.` `def` `countZeroes(mat):` `    `  `    ``# start from bottom-left` `    ``# corner of the matrix` `    ``N ``=` `5``;` `    ``row ``=` `N ``-` `1``;` `    ``col ``=` `0``;`   `    ``# stores number of ` `    ``# zeroes in the matrix` `    ``count ``=` `0``;`   `    ``while` `(col < N):` `        `  `        ``# move up until` `        ``# you find a 0` `        ``while` `(mat[row][col]):` `            `  `            ``# if zero is not found ` `            ``# in current column, we ` `            ``# are done` `            ``if` `(row < ``0``):` `                ``return` `count;` `            ``row ``=` `row ``-` `1``;`   `        ``# add 0s present in` `        ``# current column to result` `        ``count ``=` `count ``+` `(row ``+` `1``);`   `        ``# move right to` `        ``# next column` `        ``col ``=` `col ``+` `1``;`   `    ``return` `count;` `    `  `# Driver Code` `mat ``=` `[[``0``, ``0``, ``0``, ``0``, ``1``],` `       ``[``0``, ``0``, ``0``, ``1``, ``1``],` `       ``[``0``, ``1``, ``1``, ``1``, ``1``],` `       ``[``1``, ``1``, ``1``, ``1``, ``1``],` `       ``[``1``, ``1``, ``1``, ``1``, ``1``]];`   `print``( countZeroes(mat));`   `# This code is contributed` `# by chandan_jnu `

## C#

 `// C# program to count number of` `// 0s in the given row-wise and` `// column-wise sorted binary matrix` `using` `System;`   `class` `GFG ` `{` `    ``public` `static` `int` `N = 5;` `    `  `    ``// Function to count number of ` `    ``// 0s in the given row-wise and` `    ``// column-wise sorted binary matrix.` `    ``static` `int` `countZeroes(``int` `[,] mat)` `    ``{` `        ``// start from bottom-left` `        ``// corner of the matrix` `        ``int` `row = N - 1, col = 0;`   `        ``// stores number of zeroes ` `        ``// in the matrix` `        ``int` `count = 0;`   `        ``while` `(col < N)` `        ``{` `            ``// move up until you find a 0` `            ``while` `(mat[row,col] > 0)`   `                ``// if zero is not found in ` `                ``// current column,` `                ``// we are done` `                ``if` `(--row < 0)` `                    ``return` `count;`   `            ``// add 0s present in current ` `            ``// column to result` `            ``count += (row + 1);`   `            ``// move right to next column` `            ``col++;` `        ``}`   `        ``return` `count;` `    ``}` `    `  `    ``// Driver Code` `    ``public` `static` `void` `Main () ` `    ``{` `        ``int` `[,] mat = { { 0, 0, 0, 0, 1 },` `                        ``{ 0, 0, 0, 1, 1 },` `                        ``{ 0, 1, 1, 1, 1 },` `                        ``{ 1, 1, 1, 1, 1 },` `                        ``{ 1, 1, 1, 1, 1 } };` `        ``Console.WriteLine(countZeroes(mat));` `    ``}` `}`   `// This code is contributed by KRV.`

## PHP

 ``

## Javascript

 ``

Output

`8`

Time complexity of above solution is O(n) since the solution follows single path from bottom-left corner to top or right edge of the matrix.
Auxiliary space used by the program is O(1). since no extra space has been taken.