Skip to content
Related Articles

Related Articles

Improve Article
Count positions in Binary Matrix having equal count of set bits in corresponding row and column
  • Difficulty Level : Medium
  • Last Updated : 12 May, 2021

Given a boolean matrix mat[][] of size M * N, the task is to print the count of indices from the matrix whose corresponding row and column contain an equal number of set bits.

Examples:

Input; mat[][] = {{0, 1}, {1, 1}}
Output: 2
Explanation:
Position (0, 0) contains 1 set bit in corresponding row {(0, 0), (0, 1)} and column {(0, 0), (1, 0)}.
Position (1, 1) contains 2 set bits in corresponding row {(1, 0), (1, 1)} and column {(0, 1), (1, 1)}.

Input: mat[][] = {{0, 1, 1, 0}, {0, 1, 0, 0}, {1, 0, 1, 0}}
Output: 5

Naive Approach: The simplest approach to solve is to count and store the number of set bits present in the elements of each row and column of the given matrix. Then, traverse the matrix and for each position, check if the count of set bits of both the row and column is equal or not. For every index for which the above condition is found to be true, increment count. Print the final value of count after complete traversal of the matrix.



Time Complexity: O(N2)
Auxiliary Space: O(N2)

Efficient Approach: To optimize the above approach, follow the steps below:

  • Initialize two temporary arrays row[] and col[] of sizes N and M respectively.
  • Traverse the matrix mat[][]. Check for every index (i, j), if mat[i][j] is equal to 1 or not. If found to be true, increment row[i] and col[j] by 1.
  • Traverse the matrix mat[][] again. Check for every index (i, j), if row[i] and col[j] are equal or not. If found to be true, increment count.
  • Print the final value of count.

Below is the implementation of the above approach:

C++14




// C++14 program to implement
// above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to return the count of indices in
// from the given binary matrix having equal
// count of set bits in its row and column
int countPosition(vector<vector<int>> mat)
{
    int n = mat.size();
    int m = mat[0].size();
 
    // Stores count of set bits in
    // corresponding column and row
    vector<int> row(n);
    vector<int> col(m);
 
    // Traverse matrix
    for(int i = 0; i < n; i++)
    {
        for(int j = 0; j < m; j++)
        {
             
            // Since 1 contains a set bit
            if (mat[i][j] == 1)
            {
                 
                // Update count of set bits
                // for current row and col
                col[j]++;
                row[i]++;
            }
        }
    }
 
    // Stores the count of
    // required indices
    int count = 0;
 
    // Traverse matrix
    for(int i = 0; i < n; i++)
    {
        for(int j = 0; j < m; j++)
        {
             
            // If current row and column
            // has equal count of set bits
            if (row[i] == col[j])
            {
                count++;
            }
        }
    }
 
    // Return count of
    // required position
    return count;
}
 
// Driver Code
int main()
{
    vector<vector<int>> mat = { { 0, 1 },
                                { 1, 1 } };
 
    cout << (countPosition(mat));
}
 
// This code is contributed by mohit kumar 29
Java



// Java Program to implement
// above approach
 
import java.util.*;
import java.lang.*;
 
class GFG {
 
    // Function to return the count of indices in
    // from the given binary matrix having equal
    // count of set bits in its row and column
    static int countPosition(int[][] mat)
    {
 
        int n = mat.length;
        int m = mat[0].length;
 
        // Stores count of set bits in
        // corresponding column and row
        int[] row = new int[n];
        int[] col = new int[m];
 
        // Traverse matrix
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
 
                // Since 1 contains a set bit
                if (mat[i][j] == 1) {
 
                    // Update count of set bits
                    // for current row and col
                    col[j]++;
                    row[i]++;
                }
            }
        }
 
        // Stores the count of
        // required indices
        int count = 0;
 
        // Traverse matrix
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
 
                // If current row and column
                // has equal count of set bits
                if (row[i] == col[j]) {
                    count++;
                }
            }
        }
 
        // Return count of
        // required position
        return count;
    }
 
    // Driver Code
    public static void main(
        String[] args)
    {
 
        int mat[][] = { { 0, 1 },
                        { 1, 1 } };
 
        System.out.println(
            countPosition(mat));
    }
}
Python3



# Python3 program to implement
# the above approach
 
# Function to return the count
# of indices in from the given
# binary matrix having equal
# count of set bits in its
# row and column
def countPosition(mat):
     
    n = len(mat)
    m = len(mat[0])
  
    # Stores count of set bits in
    # corresponding column and row
    row = [0] * n
    col = [0] * m
  
    # Traverse matrix
    for i in range(n):
        for j in range(m):
              
            # Since 1 contains a set bit
            if (mat[i][j] == 1):
                  
                # Update count of set bits
                # for current row and col
                col[j] += 1
                row[i] += 1
         
    # Stores the count of
    # required indices
    count = 0
  
    # Traverse matrix
    for i in range(n):
        for j in range(m):
              
            # If current row and column
            # has equal count of set bits
            if (row[i] == col[j]):
                count += 1
  
    # Return count of
    # required position
    return count
  
# Driver Code
mat = [ [ 0, 1 ],
        [ 1, 1 ] ]
  
print(countPosition(mat))
 
# This code is contributed by sanjoy_62
C#



// C# Program to implement
// above approach
using System;
class GFG{
 
// Function to return the count of indices in
// from the given binary matrix having equal
// count of set bits in its row and column
static int countPosition(int[,] mat)
{
 
  int n = mat.GetLength(0);
  int m = mat.GetLength(1);
 
  // Stores count of set bits in
  // corresponding column and row
  int[] row = new int[n];
  int[] col = new int[m];
 
  // Traverse matrix
  for (int i = 0; i < n; i++)
  {
    for (int j = 0; j < m; j++)
    {
      // Since 1 contains a set bit
      if (mat[i, j] == 1)
      {
        // Update count of set bits
        // for current row and col
        col[j]++;
        row[i]++;
      }
    }
  }
 
  // Stores the count of
  // required indices
  int count = 0;
 
  // Traverse matrix
  for (int i = 0; i < n; i++)
  {
    for (int j = 0; j < m; j++)
    {
      // If current row and column
      // has equal count of set bits
      if (row[i] == col[j])
      {
        count++;
      }
    }
  }
 
  // Return count of
  // required position
  return count;
}
 
// Driver Code
public static void Main(String[] args)
{
  int [,]mat = {{0, 1},
                {1, 1}};
  Console.WriteLine(countPosition(mat));
}
}
 
// This code is contributed by Rajput-Ji
Javascript



<script>
 
// Javascript program to implement
// above approach
 
// Function to return the count of indices in
// from the given binary matrix having equal
// count of set bits in its row and column
function countPosition(mat)
{
    var n = mat.length;
    var m = mat[0].length;
 
    // Stores count of set bits in
    // corresponding column and row
    var row = Array.from({length: n}, (_, i) => 0);
    var col = Array.from({length: m}, (_, i) => 0);
 
    // Traverse matrix
    for(i = 0; i < n; i++)
    {
        for(j = 0; j < m; j++)
        {
             
            // Since 1 contains a set bit
            if (mat[i][j] == 1)
            {
                 
                // Update count of set bits
                // for current row and col
                col[j]++;
                row[i]++;
            }
        }
    }
 
    // Stores the count of
    // required indices
    var count = 0;
 
    // Traverse matrix
    for(i = 0; i < n; i++)
    {
        for(j = 0; j < m; j++)
        {
             
            // If current row and column
            // has equal count of set bits
            if (row[i] == col[j])
            {
                count++;
            }
        }
    }
 
    // Return count of
    // required position
    return count;
}
 
// Driver Code
var mat = [ [ 0, 1 ],
            [ 1, 1 ] ];
 
document.write(countPosition(mat));
 
// This code is contributed by Rajput-Ji
 
</script>
Output: 
2
 
Time Complexity: O(N * M)
Auxiliary Space: O(N+M)
Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.
In case you wish to attend live classes with industry experts, please refer Geeks Classes Live 



My Personal Notes
arrow_drop_up
Previous
Pair having all other given pairs lying between its minimum and maximum
Next

Maximize length of subarray having equal elements by adding at most K
Recommended Articles
Page :
Generate a Matrix such that given Matrix elements are equal to Bitwise OR of all corresponding row and column elements of generated Matrix
15, Jan 21
Count levels in a Binary Tree consisting of node values having set bits at different positions
29, Jan 21
Count 1s in binary matrix having remaining indices of its row and column filled with 0s
23, Sep 20
Number of positions with Same address in row major and column major order
01, Jun 18
Leftmost Column with atleast one 1 in a row-wise sorted binary matrix | Set 2
09, May 20
Find trace of matrix formed by adding Row-major and Column-major order of same matrix
04, Dec 17
Check if a given matrix can be converted to another given matrix by row and column exchanges
30, Apr 20
Filling diagonal to make the sum of every row, column and diagonal equal of 3x3 matrix
27, Jan 19
Find if a binary matrix exists with given row and column sums
11, Jun 19
Construct a Binary Matrix whose sum of each row and column is a Prime Number
27, Oct 20
Check if Bitwise AND of concatenation of diagonals exceeds that of middle row/column elements of a Binary Matrix
06, Apr 21
Count of pairs {X, Y} from an array such that sum of count of set bits in X ⊕ Y and twice the count of set bits in X & Y is M
12, Mar 21
Minimum row or column swaps required to make every pair of adjacent cell of a Binary Matrix distinct
07, Jan 21
Leftmost Column with atleast one 1 in a row-wise sorted binary matrix
07, May 20
Check whether row or column swaps produce maximum size binary sub-matrix with all 1s
03, Feb 17
Print all positions of a given string having count of smaller characters equal on both sides
25, Oct 20
Count of ways to generate a Matrix with product of each row and column as 1 or -1
08, Jul 20
Count Negative Numbers in a Column-Wise and Row-Wise Sorted Matrix
17, Mar 16
Count zeros in a row wise and column wise sorted matrix
20, Jul 16
Find a number containing N - 1 set bits at even positions from the right
25, Jun 19
Find row number of a binary matrix having maximum number of 1s
09, Sep 17
Print all elements in sorted order from row and column wise sorted matrix
22, Oct 14
Given a Boolean Matrix, find k such that all elements in k'th row are 0 and k'th column are 1.
24, Sep 15
Minimum operations required to make each row and column of matrix equals
25, Dec 17
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
offbeat
@offbeat
Vote for difficulty
Current difficulty :
Medium





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox