Count zeros in a row wise and column wise sorted matrix

Last Updated : 19 Nov, 2024

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.

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.

Decrement row index until we find a 0.
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++

#include <iostream>
#include <vector>
using namespace std;

// Function to count number of 0s in the given
// row-wise and column-wise sorted binary matrix.
int countZeroes(const vector<vector<int>>& mat) {
    int n = mat.size();    
  
    // start from the bottom-left corner
    int row = n - 1, col = 0;
    int count = 0;          

    while (col < n) {
      
        // move up until you find a 0
        while (row >= 0 && mat[row][col]) {
            row--;
        }

        // add the number of 0s in the current
        // column to the result
        count += (row + 1);

        // move to the next column
        col++;
    }

    return count;
}

int main() {
    vector<vector<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 }
    };

    cout << countZeroes(mat);

    return 0;
}

// C program to count number of 0s in the given
// row-wise and column-wise sorted binary matrix.
#include <stdio.h>

// 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;
}

Java

import java.util.Arrays;

public class GfG {
  
    // Function to count number of 0s in the given
    // row-wise and column-wise sorted binary matrix.
    public static int countZeroes(int[][] mat) {
        int n = mat.length;
        
        // start from the bottom-left corner
        int row = n - 1, col = 0;
        int count = 0;

        while (col < n) {
            
            // move up until you find a 0
            while (row >= 0 && mat[row][col] == 1) {
                row--;
            }

            // add the number of 0s in the current
            // column to the result
            count += (row + 1);

            // move to the next column
            col++;
        }

        return count;
    }

    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));
    }
}

Python

# Function to count number of 0s in the given
# row-wise and column-wise sorted binary matrix.
def count_zeroes(mat):
    n = len(mat)
    
    # start from the bottom-left corner
    row = n - 1
    col = 0
    count = 0

    while col < n:
        
        # move up until you find a 0
        while row >= 0 and mat[row][col]:
            row -= 1

        # add the number of 0s in the current
        # column to the result
        count += (row + 1)

        # move to the next column
        col += 1

    return count

if __name__ == '__main__':
    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(count_zeroes(mat))

// Function to count number of 0s in the given
// row-wise and column-wise sorted binary matrix.
using System;
using System.Collections.Generic;

class Program {
    static int CountZeroes(int[,] mat) {
        int n = mat.GetLength(0);
      
        // start from the bottom-left corner
        int row = n - 1, col = 0;
        int count = 0;

        while (col < n) {
          
            // move up until you find a 0
            while (row >= 0 && mat[row, col] == 1) {
                row--;
            }
          
            // add the number of 0s in the current
            // column to the result
            count += (row + 1);
          
            // move to the next column
            col++;
        }
        return count;
    }

    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));
    }
}

JavaScript

// Function to count number of 0s in the given
// row-wise and column-wise sorted binary matrix.
function countZeroes(mat) {
    const n = mat.length;
    
    // start from the bottom-left corner
    let row = n - 1, col = 0;
    let count = 0;

    while (col < n) {
    
        // move up until you find a 0
        while (row >= 0 && mat[row][col]) {
            row--;
        }
        
        // add the number of 0s in the current
        // column to the result
        count += (row + 1);
        
        // move to the next column
        col++;
    }
    return count;
}

const 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.log(countZeroes(mat));

Output

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.