Related Articles

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

• Last Updated : 08 Jun, 2021

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 ``using` `namespace` `std;` `// Function to find the number of``// even cell in a 2D matrix``int` `findNumberOfEvenCells(``int` `n, ``int` `q[], ``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];``        ``int` `y = q[i];` `        ``// 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[] = { { 1, 1 },``                   ``{ 1, 2 },``                   ``{ 2, 1 } };` `    ``int` `size = ``sizeof``(q) / ``sizeof``(q);``    ``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

 ``
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