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

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:2Explanation: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 2Input: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(N

^{2})

__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+1
^{th}row and col[i] will store the number of operations on i+1^{th}column. - If 1 is to be added to i
^{th}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**.