给定一个由非负整数组成的N * N矩阵mat [] []以及由子矩阵的左上角和右下角组成的一些查询，任务是查找所有元素的按位与每个查询中给定的子矩阵的数量。
例子：
Input: mat[][] = {
{1, 2, 3},
{4, 5, 6},
{7, 8, 9}},
q[] = {{1, 1, 1, 1}, {1, 2, 2, 2}}
Output:
5
0
Query 1: Only element in the sub-matrix is 5.
Query 2: 6 AND 9 = 0
Input: mat[][] = {
{12, 23, 13},
{41, 15, 46},
{75, 82, 123}},
q[] = {{0, 0, 2, 2}, {1, 1, 2, 2}}
Output:
0
2
天真的方法：遍历子矩阵并找到该范围内所有数字的按位与。在最坏的情况下，每个查询将花费O(n 2 )时间。
有效的方法：如果我们看一下整数作为二进制数，我们可以很容易地看到，条件我我们的答案是一套次的一点是，我所有的子矩阵的整数个位应设置。
因此，我们将为每个位计算前缀计数。我们将使用它来查找设置了第i位的子矩阵中的整数数量。如果它等于子矩阵的总元素，那么我们答案的第i位也将被设置。
为此，我们将创建一个3d数组prefix_count [] [] [] ，其中prefix_count [i] [x] [y]将存储子矩阵的所有元素的计数，其左上角位于{0， 0} ，位于{x，y}的右下角，第i个位置1。参考
本文了解矩阵情况下的prefix_count。
下面是上述方法的实现：
C++
// 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][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
int rangeAnd(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 whose ith bit
// is set equals to the total
// elements in the sub-matrix
if (p == (x2 - x1 + 1) * (y2 - y1 + 1))
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[][4] = { { 1, 1, 1, 1 }, { 1, 2, 2, 2 } };
int q = sizeof(queries) / sizeof(queries[0]);
for (int i = 0; i < q; i++)
cout << rangeAnd(queries[i][0],
queries[i][1],
queries[i][2],
queries[i][3])
<< endl;
return 0;
} Java
// 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 rangeAnd(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 whose ith bit
// is set equals to the total
// elements in the sub-matrix
if (p == (x2 - x1 + 1) * (y2 - y1 + 1))
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( rangeAnd(queries[i][0],
queries[i][1],
queries[i][2],
queries[i][3]) );
}
}
// This code is contributed by AnkitRaiPython3
# 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 == (x2 - x1 + 1) * (y2 - y1 + 1)):
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_GangwarC#
// 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 rangeAnd(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 whose ith bit
// is set equals to the total
// elements in the sub-matrix
if (p == (x2 - x1 + 1) * (y2 - y1 + 1))
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( rangeAnd(queries[i,0],
queries[i,1],
queries[i,2],
queries[i,3]) );
}
}
/* This code contributed by PrinciRaj1992 */输出：
5
0
预计算的时间复杂度为O(n 2 )，每个查询都可以在O(1)中回答