Related Articles
Find Number of Even cells in a Zero Matrix after Q queries
• Last Updated : 20 Jan, 2020

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

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

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

My Personal Notes arrow_drop_up