Skip to content
Related Articles

Related Articles

Improve Article

Find Number of Even cells in a Zero Matrix after Q queries

  • Last Updated : 08 Jun, 2021
Geek Week

Given a Zero matrix of N x N size, the task is to find the numbers of cells containing even numbers after performing Q queries. Each query will be in the form of (X, Y) such that for a given cell (X, Y), an increment operation has to be performed on all cells in the X’th row and Y’th column.
Note: The initial 0’s are also to be taken as even numbers in the count.
Examples: 
 

Input: N = 2, Q = { {1, 1}, {1, 2}, {2, 1} }
Output: 2
Explanation:
In the first query, we add 1  
to all elements of row 1 and column 1.
Our matrix become
2 1
1 0

In the second query, we add 1
to all elements of row 1 and column 2.
Our matrix become
3 3
1 1

In the last query, we add 1
to all elements of row 2 and column 1.
Our matrix finally become
4 3
3 2

In the final updated matrix, there 
are 2 even numbers 4 and 3 
respectively, hence ans is 2

Input: N = 2, Q = { {1, 1} } 
Output: 1

 

Naive Approach: The Naive approach would be to update each and every cell in the matrix as per the query. Then traverse the matrix to find out the even cells.
Time Complexity: O(N2)
Efficient Approach: 
 

  • Maintain two arrays, one for rows operation and one for column operation.
  • The row[i] will store the number of operations on i+1th row and col[i] will store the number of operations on i+1th column.
  • If 1 is to be added to ith row, we will do row[i-1]++, assuming 0 based indexing.
  • Same for columns.
  • Now, we need to observe that odd + odd = even and even + even = even.
  • Hence if row[i] and col[j] are both odd or even, then that cell will have even value.
  • So we need to just count odd and even values in both arrays and multiply them.

Below is the implementation of above approach: 
 

C++




// C++ program find Number of Even cells
// in a Zero Matrix after Q queries
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to find the number of
// even cell in a 2D matrix
int findNumberOfEvenCells(int n, int q[][2], int size)
{
 
    // Maintain two arrays, one for rows operation
    // and one for column operation
    int row[n] = { 0 };
    int col[n] = { 0 };
 
    for (int i = 0; i < size; i++) {
        int x = q[i][0];
        int y = q[i][1];
 
        // Increment operation on row[i]
        row[x - 1]++;
 
        // Increment operation on col[i]
        col[y - 1]++;
    }
 
    int r1 = 0, r2 = 0;
    int c1 = 0, c2 = 0;
 
    // Count odd and even values in
    // both arrays and multiply them
    for (int i = 0; i < n; i++) {
 
        // Count of rows having even numbers
        if (row[i] % 2 == 0) {
            r1++;
        }
        // Count of rows having odd numbers
        if (row[i] % 2 == 1) {
            r2++;
        }
        // Count of columns having even numbers
        if (col[i] % 2 == 0) {
            c1++;
        }
        // Count of columns having odd numbers
        if (col[i] % 2 == 1) {
            c2++;
        }
    }
 
    int count = r1 * c1 + r2 * c2;
 
    return count;
}
 
// Driver code
int main()
{
 
    int n = 2;
    int q[][2] = { { 1, 1 },
                   { 1, 2 },
                   { 2, 1 } };
 
    int size = sizeof(q) / sizeof(q[0]);
    cout << findNumberOfEvenCells(n, q, size);
 
    return 0;
}

Java




// Java program find Number of Even cells
// in a Zero Matrix after Q queries
class GFG
{
     
    // Function to find the number of
    // even cell in a 2D matrix
    static int findNumberOfEvenCells(int n, int q[][], int size)
    {
     
        // Maintain two arrays, one for rows operation
        // and one for column operation
        int row[] = new int[n] ;
        int col[] = new int[n] ;
     
        for (int i = 0; i < size; i++)
        {
            int x = q[i][0];
            int y = q[i][1];
     
            // Increment operation on row[i]
            row[x - 1]++;
     
            // Increment operation on col[i]
            col[y - 1]++;
        }
     
        int r1 = 0, r2 = 0;
        int c1 = 0, c2 = 0;
     
        // Count odd and even values in
        // both arrays and multiply them
        for (int i = 0; i < n; i++)
        {
     
            // Count of rows having even numbers
            if (row[i] % 2 == 0)
            {
                r1++;
            }
             
            // Count of rows having odd numbers
            if (row[i] % 2 == 1)
            {
                r2++;
            }
             
            // Count of columns having even numbers
            if (col[i] % 2 == 0)
            {
                c1++;
            }
             
            // Count of columns having odd numbers
            if (col[i] % 2 == 1)
            {
                c2++;
            }
        }
     
        int count = r1 * c1 + r2 * c2;
        return count;
    }
     
    // Driver code
    public static void main (String[] args)
    {
     
        int n = 2;
        int q[][] = { { 1, 1 },
                    { 1, 2 },
                    { 2, 1 } };
     
        int size = q.length;
        System.out.println(findNumberOfEvenCells(n, q, size));
    }
}
 
// This code is contributed by AnkitRai01

Python3




# Python3 program find Number of Even cells
# in a Zero Matrix after Q queries
 
# Function to find the number of
# even cell in a 2D matrix
def findNumberOfEvenCells(n, q, size) :
     
    # Maintain two arrays, one for rows operation
    # and one for column operation
    row = [0]*n ;
    col = [0]*n
     
    for i in range(size) :
        x = q[i][0];
        y = q[i][1];
         
        # Increment operation on row[i]
        row[x - 1] += 1;
         
        # Increment operation on col[i]
        col[y - 1] += 1;
         
    r1 = 0;
    r2 = 0;
    c1 = 0;
    c2 = 0;
     
    # Count odd and even values in
    # both arrays and multiply them
    for i in range(n) :
        # Count of rows having even numbers
        if (row[i] % 2 == 0) :
            r1 += 1;
             
        # Count of rows having odd numbers
        if (row[i] % 2 == 1) :
            r2 += 1;
             
        # Count of columns having even numbers
        if (col[i] % 2 == 0) :
            c1 +=1;
             
        # Count of columns having odd numbers
        if (col[i] % 2 == 1) :
            c2 += 1;
             
    count = r1 * c1 + r2 * c2;
     
    return count;
 
 
# Driver code
if __name__ == "__main__" :
 
    n = 2;
    q = [ [ 1, 1 ],
            [ 1, 2 ],
            [ 2, 1 ] ];
 
    size = len(q);
     
    print(findNumberOfEvenCells(n, q, size));
 
# This code is contributed by AnkitRai01

C#




// C# program find Number of Even cells
// in a Zero Matrix after Q queries
using System;
 
class GFG
{
     
    // Function to find the number of
    // even cell in a 2D matrix
    static int findNumberOfEvenCells(int n, int [,]q, int size)
    {
     
        // Maintain two arrays, one for rows operation
        // and one for column operation
        int []row = new int[n] ;
        int []col = new int[n] ;
     
        for (int i = 0; i < size; i++)
        {
            int x = q[i, 0];
            int y = q[i, 1];
     
            // Increment operation on row[i]
            row[x - 1]++;
     
            // Increment operation on col[i]
            col[y - 1]++;
        }
     
        int r1 = 0, r2 = 0;
        int c1 = 0, c2 = 0;
     
        // Count odd and even values in
        // both arrays and multiply them
        for (int i = 0; i < n; i++)
        {
     
            // Count of rows having even numbers
            if (row[i] % 2 == 0)
            {
                r1++;
            }
             
            // Count of rows having odd numbers
            if (row[i] % 2 == 1)
            {
                r2++;
            }
             
            // Count of columns having even numbers
            if (col[i] % 2 == 0)
            {
                c1++;
            }
             
            // Count of columns having odd numbers
            if (col[i] % 2 == 1)
            {
                c2++;
            }
        }
     
        int count = r1 * c1 + r2 * c2;
        return count;
    }
     
    // Driver code
    public static void Main ()
    {
     
        int n = 2;
        int [,]q = { { 1, 1 },
                    { 1, 2 },
                    { 2, 1 } };
     
        int size = q.GetLength(0);
        Console.WriteLine(findNumberOfEvenCells(n, q, size));
    }
}
 
// This code is contributed by AnkitRai01

Javascript




<script>
 
    // JavaScript program find Number of Even cells
    // in a Zero Matrix after Q queries
     
    // Function to find the number of
    // even cell in a 2D matrix
    function findNumberOfEvenCells(n, q, size)
    {
       
        // Maintain two arrays, one for rows operation
        // and one for column operation
        let row = new Array(n);
        row.fill(0);
        let col = new Array(n);
        col.fill(0);
       
        for (let i = 0; i < size; i++)
        {
            let x = q[i][0];
            let y = q[i][1];
       
            // Increment operation on row[i]
            row[x - 1]++;
       
            // Increment operation on col[i]
            col[y - 1]++;
        }
       
        let r1 = 0, r2 = 0;
        let c1 = 0, c2 = 0;
       
        // Count odd and even values in
        // both arrays and multiply them
        for (let i = 0; i < n; i++)
        {
       
            // Count of rows having even numbers
            if (row[i] % 2 == 0)
            {
                r1++;
            }
               
            // Count of rows having odd numbers
            if (row[i] % 2 == 1)
            {
                r2++;
            }
               
            // Count of columns having even numbers
            if (col[i] % 2 == 0)
            {
                c1++;
            }
               
            // Count of columns having odd numbers
            if (col[i] % 2 == 1)
            {
                c2++;
            }
        }
       
        let count = r1 * c1 + r2 * c2;
        return count;
    }
     
    let n = 2;
    let q = [ [ 1, 1 ],
              [ 1, 2 ],
              [ 2, 1 ] ];
 
    let size = q.length;
    document.write(findNumberOfEvenCells(n, q, size));
 
</script>
Output: 



2

 

Time Complexity: O(N)
 

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 experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.




My Personal Notes arrow_drop_up
Recommended Articles
Page :