# Queries for bitwise OR in the given matrix

Given an N * N matrix mat[][] consisting of non-negative integers and some queries consisting of top-left and bottom-right corner of the sub-matrix, the task is to find the bit-wise OR of all the elements of the sub-matrix given in each query.

Examples:

Input: mat[][] = {
{1, 2, 3},
{4, 5, 6},
{7, 8, 9}},
q[] = {{1, 1, 1, 1}, {1, 2, 2, 2}}
Output:
5
15
Query 1: Only element in the sub-matrix is 5.
Query 2: 6 OR 9 = 15

Input: mat[][] = {
{12, 23, 13},
{41, 15, 46},
{75, 82, 123}},
q[] = {{0, 0, 2, 2}, {1, 1, 2, 1}}
Output:
127
95

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

Naive approach: Iterate through the sub-matrix and find the bit-wise OR of all the numbers in that range. This will take O(n2) time for each query in the worst case.

Efficient approach: If we look at the integers as binary number, we can easily see that condition for ith bit of our answer to be set is that ith bit of at least one integer in the sub-matrix is set.
So, we will calculate prefix-count for each bit. We will use this to find the number of integers in the sub-matrix with ith bit set. If it is non-zero then the ith bit of our answer will also be set.
For this, we will create a 3d-array, prefix_count[][][] where prefix_count[i][x][y] will store the count of all the elements of the sub-matrix with top left corner at {0, 0} and bottom right corner at {x, y} and ith bit set. Refer

Below is the implementation of the above approach:

 `// C++ implementation of the approach ` `#include ` `#define bitscount 32 ` `#define n 3 ` `using` `namespace` `std; ` ` `  `// Array to store bit-wise ` `// prefix count ` `int` `prefix_count[bitscount][n][n]; ` ` `  `// Function to find the prefix sum ` `void` `findPrefixCount(``int` `arr[][n]) ` `{ ` ` `  `    ``// Loop for each bit ` `    ``for` `(``int` `i = 0; i < bitscount; i++) { ` ` `  `        ``// Loop to find prefix-count ` `        ``// for each row ` `        ``for` `(``int` `j = 0; j < n; j++) { ` `            ``prefix_count[i][j] = ((arr[j] >> i) & 1); ` `            ``for` `(``int` `k = 1; k < n; k++) { ` `                ``prefix_count[i][j][k] = ((arr[j][k] >> i) & 1); ` `                ``prefix_count[i][j][k] += prefix_count[i][j][k - 1]; ` `            ``} ` `        ``} ` `    ``} ` ` `  `    ``// Finding column-wise prefix ` `    ``// count ` `    ``for` `(``int` `i = 0; i < bitscount; i++) ` `        ``for` `(``int` `j = 1; j < n; j++) ` `            ``for` `(``int` `k = 0; k < n; k++) ` `                ``prefix_count[i][j][k] += prefix_count[i][j - 1][k]; ` `} ` ` `  `// Function to return the result for a query ` `int` `rangeOr(``int` `x1, ``int` `y1, ``int` `x2, ``int` `y2) ` `{ ` ` `  `    ``// To store the answer ` `    ``int` `ans = 0; ` ` `  `    ``// Loop for each bit ` `    ``for` `(``int` `i = 0; i < bitscount; i++) { ` ` `  `        ``// To store the number of variables ` `        ``// with ith bit set ` `        ``int` `p; ` `        ``if` `(x1 == 0 and y1 == 0) ` `            ``p = prefix_count[i][x2][y2]; ` `        ``else` `if` `(x1 == 0) ` `            ``p = prefix_count[i][x2][y2] ` `                ``- prefix_count[i][x2][y1 - 1]; ` `        ``else` `if` `(y1 == 0) ` `            ``p = prefix_count[i][x2][y2] ` `                ``- prefix_count[i][x1 - 1][y2]; ` `        ``else` `            ``p = prefix_count[i][x2][y2] ` `                ``- prefix_count[i][x1 - 1][y2] ` `                ``- prefix_count[i][x2][y1 - 1] ` `                ``+ prefix_count[i][x1 - 1][y1 - 1]; ` ` `  `        ``// If count of variables with ith bit ` `        ``// set is greater than 0 ` `        ``if` `(p != 0) ` `            ``ans = (ans | (1 << i)); ` `    ``} ` ` `  `    ``return` `ans; ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``int` `arr[][n] = { { 1, 2, 3 }, ` `                     ``{ 4, 5, 6 }, ` `                     ``{ 7, 8, 9 } }; ` ` `  `    ``findPrefixCount(arr); ` ` `  `    ``int` `queries[] = { { 1, 1, 1, 1 }, { 1, 2, 2, 2 } }; ` `    ``int` `q = ``sizeof``(queries) / ``sizeof``(queries); ` ` `  `    ``for` `(``int` `i = 0; i < q; i++) ` `        ``cout << rangeOr(queries[i], ` `                        ``queries[i], ` `                        ``queries[i], ` `                        ``queries[i]) ` `             ``<< endl; ` ` `  `    ``return` `0; ` `} `

 `// Java implementation of the approach  ` ` `  `class` `GFG ` `{ ` ` `  `    ``final` `static` `int` `bitscount = ``32` `; ` `    ``final` `static` `int` `n = ``3` `; ` ` `  `    ``// Array to store bit-wise  ` `    ``// prefix count  ` `    ``static` `int` `prefix_count[][][] = ``new` `int` `[bitscount][n][n];  ` `     `  `    ``// Function to find the prefix sum  ` `    ``static` `void` `findPrefixCount(``int` `arr[][])  ` `    ``{  ` `     `  `        ``// Loop for each bit  ` `        ``for` `(``int` `i = ``0``; i < bitscount; i++) ` `        ``{  ` `     `  `            ``// Loop to find prefix-count  ` `            ``// for each row  ` `            ``for` `(``int` `j = ``0``; j < n; j++) ` `            ``{  ` `                ``prefix_count[i][j][``0``] = ((arr[j][``0``] >> i) & ``1``);  ` `                ``for` `(``int` `k = ``1``; k < n; k++) ` `                ``{  ` `                    ``prefix_count[i][j][k] = ((arr[j][k] >> i) & ``1``);  ` `                    ``prefix_count[i][j][k] += prefix_count[i][j][k - ``1``];  ` `                ``}  ` `            ``}  ` `        ``}  ` `     `  `        ``// Finding column-wise prefix  ` `        ``// count  ` `        ``for` `(``int` `i = ``0``; i < bitscount; i++)  ` `            ``for` `(``int` `j = ``1``; j < n; j++)  ` `                ``for` `(``int` `k = ``0``; k < n; k++)  ` `                    ``prefix_count[i][j][k] += prefix_count[i][j - ``1``][k];  ` `    ``}  ` `     `  `    ``// Function to return the result for a query  ` `    ``static` `int` `rangeOr(``int` `x1, ``int` `y1, ``int` `x2, ``int` `y2)  ` `    ``{  ` `     `  `        ``// To store the answer  ` `        ``int` `ans = ``0``;  ` `     `  `        ``// Loop for each bit  ` `        ``for` `(``int` `i = ``0``; i < bitscount; i++)  ` `        ``{  ` `     `  `            ``// To store the number of variables  ` `            ``// with ith bit set  ` `            ``int` `p;  ` `            ``if` `(x1 == ``0` `&& y1 == ``0``)  ` `                ``p = prefix_count[i][x2][y2];  ` `            ``else` `if` `(x1 == ``0``)  ` `                ``p = prefix_count[i][x2][y2]  ` `                    ``- prefix_count[i][x2][y1 - ``1``];  ` `            ``else` `if` `(y1 == ``0``)  ` `                ``p = prefix_count[i][x2][y2]  ` `                    ``- prefix_count[i][x1 - ``1``][y2];  ` `            ``else` `                ``p = prefix_count[i][x2][y2]  ` `                    ``- prefix_count[i][x1 - ``1``][y2]  ` `                    ``- prefix_count[i][x2][y1 - ``1``]  ` `                    ``+ prefix_count[i][x1 - ``1``][y1 - ``1``];  ` `     `  `            ``// If count of variables with ith bit  ` `            ``// set is greater than 0  ` `            ``if` `(p != ``0``)  ` `                ``ans = (ans | (``1` `<< i));  ` `        ``}  ` `     `  `        ``return` `ans;  ` `    ``}  ` `     `  `    ``// Driver code  ` `    ``public` `static` `void` `main (String[] args)  ` `    ``{ ` `        ``int` `arr[][] = { { ``1``, ``2``, ``3` `},  ` `                        ``{ ``4``, ``5``, ``6` `},  ` `                        ``{ ``7``, ``8``, ``9` `} };  ` `     `  `        ``findPrefixCount(arr);  ` `     `  `        ``int` `queries[][] = { { ``1``, ``1``, ``1``, ``1` `}, { ``1``, ``2``, ``2``, ``2` `} };  ` `        ``int` `q = queries.length;  ` `     `  `        ``for` `(``int` `i = ``0``; i < q; i++)  ` `            ``System.out.println( rangeOr(queries[i][``0``],  ` `                            ``queries[i][``1``],  ` `                            ``queries[i][``2``],  ` `                            ``queries[i][``3``]) ); ` `    ``} ` `} ` ` `  `// This code is contributed by AnkitRai `

 `# Python 3 implementation of the approach ` `bitscount ``=` `32` `n ``=` `3` `# Array to store bit-wise ` `# prefix count ` `prefix_count ``=` `[[[``0` `for` `i ``in` `range``(n)] ``for` `j ``in` `range``(n)] ``for` `k ``in` `range``(bitscount)] ` ` `  `# Function to find the prefix sum ` `def` `findPrefixCount(arr): ` `    ``# Loop for each bit ` `    ``for` `i ``in` `range``(bitscount): ` `        ``# Loop to find prefix-count ` `        ``# for each row ` `        ``for` `j ``in` `range``(n): ` `            ``prefix_count[i][j][``0``] ``=` `((arr[j][``0``] >> i) & ``1``) ` `            ``for` `k ``in` `range``(``1``,n): ` `                ``prefix_count[i][j][k] ``=` `((arr[j][k] >> i) & ``1``) ` `                ``prefix_count[i][j][k] ``+``=` `prefix_count[i][j][k ``-` `1``] ` ` `  `    ``# Finding column-wise prefix ` `    ``# count ` `    ``for` `i ``in` `range``(bitscount): ` `        ``for` `j ``in` `range``(``1``,n): ` `            ``for` `k ``in` `range``(n): ` `                ``prefix_count[i][j][k] ``+``=` `prefix_count[i][j ``-` `1``][k] ` ` `  `# Function to return the result for a query ` `def` `rangeOr(x1, y1, x2, y2): ` `    ``# To store the answer ` `    ``ans ``=` `0` ` `  `    ``# Loop for each bit ` `    ``for` `i ``in` `range``(bitscount): ` `        ``# To store the number of variables ` `        ``# with ith bit set ` `        ``if` `(x1 ``=``=` `0` `and` `y1 ``=``=` `0``): ` `            ``p ``=` `prefix_count[i][x2][y2] ` `        ``elif` `(x1 ``=``=` `0``): ` `            ``p ``=` `prefix_count[i][x2][y2] ``-` `prefix_count[i][x2][y1 ``-` `1``] ` `        ``elif` `(y1 ``=``=` `0``): ` `            ``p ``=` `prefix_count[i][x2][y2] ``-` `prefix_count[i][x1 ``-` `1``][y2] ` `        ``else``: ` `            ``p ``=` `prefix_count[i][x2][y2] ``-` `prefix_count[i][x1 ``-` `1``][y2] ``-` `prefix_count[i][x2][y1 ``-` `1``] ``+` `prefix_count[i][x1 ``-` `1``][y1 ``-` `1``]; ` ` `  `        ``# If count of variables with ith bit ` `        ``# set is greater than 0 ` `        ``if` `(p !``=` `0``): ` `            ``ans ``=` `(ans | (``1` `<< i)) ` ` `  `    ``return` `ans ` ` `  `# Driver code ` `if` `__name__ ``=``=` `'__main__'``: ` `    ``arr ``=`  `[[``1``, ``2``, ``3``], ` `            ``[``4``, ``5``, ``6``], ` `            ``[``7``, ``8``, ``9``]] ` ` `  `    ``findPrefixCount(arr) ` `    ``queries ``=` `[[``1``, ``1``, ``1``, ``1``], ` `                        ``[``1``, ``2``, ``2``, ``2``]] ` `    ``q ``=` `len``(queries) ` ` `  `    ``for` `i ``in` `range``(q): ` `        ``print``(rangeOr(queries[i][``0``],queries[i][``1``],queries[i][``2``],queries[i][``3``])) ` `         `  `# This code is contributed by ` `# Surendra_Gangwar `

 `// C# implementation of the approach ` `using` `System; ` `     `  `class` `GFG ` `{ ` ` `  `    ``static` `int` `bitscount = 32 ; ` `    ``static` `int` `n = 3 ; ` ` `  `    ``// Array to store bit-wise  ` `    ``// prefix count  ` `    ``static` `int` `[,,]prefix_count = ``new` `int` `[bitscount,n,n];  ` `     `  `    ``// Function to find the prefix sum  ` `    ``static` `void` `findPrefixCount(``int` `[,]arr)  ` `    ``{  ` `     `  `        ``// Loop for each bit  ` `        ``for` `(``int` `i = 0; i < bitscount; i++) ` `        ``{  ` `     `  `            ``// Loop to find prefix-count  ` `            ``// for each row  ` `            ``for` `(``int` `j = 0; j < n; j++) ` `            ``{  ` `                ``prefix_count[i,j,0] = ((arr[j,0] >> i) & 1);  ` `                ``for` `(``int` `k = 1; k < n; k++) ` `                ``{  ` `                    ``prefix_count[i, j, k] = ((arr[j, k] >> i) & 1);  ` `                    ``prefix_count[i, j, k] += prefix_count[i, j, k - 1];  ` `                ``}  ` `            ``}  ` `        ``}  ` `     `  `        ``// Finding column-wise prefix  ` `        ``// count  ` `        ``for` `(``int` `i = 0; i < bitscount; i++)  ` `            ``for` `(``int` `j = 1; j < n; j++)  ` `                ``for` `(``int` `k = 0; k < n; k++)  ` `                    ``prefix_count[i, j, k] += prefix_count[i, j - 1, k];  ` `    ``}  ` `     `  `    ``// Function to return the result for a query  ` `    ``static` `int` `rangeOr(``int` `x1, ``int` `y1, ``int` `x2, ``int` `y2)  ` `    ``{  ` `     `  `        ``// To store the answer  ` `        ``int` `ans = 0;  ` `     `  `        ``// Loop for each bit  ` `        ``for` `(``int` `i = 0; i < bitscount; i++)  ` `        ``{  ` `     `  `            ``// To store the number of variables  ` `            ``// with ith bit set  ` `            ``int` `p;  ` `            ``if` `(x1 == 0 && y1 == 0)  ` `                ``p = prefix_count[i, x2, y2];  ` `            ``else` `if` `(x1 == 0)  ` `                ``p = prefix_count[i, x2, y2]  ` `                    ``- prefix_count[i, x2, y1 - 1];  ` `            ``else` `if` `(y1 == 0)  ` `                ``p = prefix_count[i, x2, y2]  ` `                    ``- prefix_count[i, x1 - 1, y2];  ` `            ``else` `                ``p = prefix_count[i, x2, y2]  ` `                    ``- prefix_count[i, x1 - 1, y2]  ` `                    ``- prefix_count[i, x2, y1 - 1]  ` `                    ``+ prefix_count[i, x1 - 1, y1 - 1];  ` `     `  `            ``// If count of variables with ith bit  ` `            ``// set is greater than 0  ` `            ``if` `(p != 0)  ` `                ``ans = (ans | (1 << i));  ` `        ``}  ` `     `  `        ``return` `ans;  ` `    ``}  ` `     `  `    ``// Driver code  ` `    ``public` `static` `void` `Main (String[] args)  ` `    ``{ ` `        ``int` `[,]arr = { { 1, 2, 3 },  ` `                        ``{ 4, 5, 6 },  ` `                        ``{ 7, 8, 9 } };  ` `     `  `        ``findPrefixCount(arr);  ` `     `  `        ``int` `[,]queries = { { 1, 1, 1, 1 }, { 1, 2, 2, 2 } };  ` `        ``int` `q = queries.GetLength(0);  ` `     `  `        ``for` `(``int` `i = 0; i < q; i++)  ` `            ``Console.WriteLine( rangeOr(queries[i,0],  ` `                            ``queries[i,1],  ` `                            ``queries[i,2],  ` `                            ``queries[i,3]) ); ` `    ``} ` `} ` ` `  `/* This code contributed by PrinciRaj1992 */`

Output:
```5
15
```

Time complexity for pre-computation is O(n2) and each query can be answered in O(1)

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.

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.

Article Tags :