📌  相关文章
📜  给定数组的索引范围[L,R]中按位AND的查询

📅  最后修改于: 2021-05-25 08:12:23             🧑  作者: Mango

给定由范围[L,R]组成的NQ个查询的数组arr [ ] 。任务是找到该索引范围内所有元素的按位与。

例子:

天真的方法:遍历该范围并找到该范围内所有数字的按位与。每个查询将花费O(n)时间。

有效的方法:如果我们看一下整数作为二进制数,我们可以很容易地看到,条件我们的答案是一套的一点是,所有在区间[L,R]整数的位应设置。
因此,我们将为每个位计算前缀计数。我们将使用它来查找设置了i位的范围内的整数数量。如果它等于范围的大小,那么我们答案的i位也将被设置。

下面是上述方法的实现:

C++
// C++ implementation of the approach
#include 
#define MAX 100000
#define bitscount 32
using namespace std;
  
// Array to store bit-wise
// prefix count
int prefix_count[bitscount][MAX];
  
// Function to find the prefix sum
void findPrefixCount(int arr[], int n)
{
  
    // Loop for each bit
    for (int i = 0; i < bitscount; i++) {
  
        // Loop to find prefix count
        prefix_count[i][0] = ((arr[0] >> i) & 1);
        for (int j = 1; j < n; j++) {
            prefix_count[i][j] = ((arr[j] >> i) & 1);
            prefix_count[i][j] += prefix_count[i][j - 1];
        }
    }
}
  
// Function to answer query
int rangeAnd(int l, int r)
{
  
    // 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 x;
        if (l == 0)
            x = prefix_count[i][r];
        else
            x = prefix_count[i][r]
                - prefix_count[i][l - 1];
  
        // Condition for ith bit
        // of answer to be set
        if (x == r - l + 1)
            ans = (ans | (1 << i));
    }
  
    return ans;
}
  
// Driver code
int main()
{
    int arr[] = { 7, 5, 3, 5, 2, 3 };
    int n = sizeof(arr) / sizeof(int);
  
    findPrefixCount(arr, n);
  
    int queries[][2] = { { 1, 3 }, { 4, 5 } };
    int q = sizeof(queries) / sizeof(queries[0]);
  
    for (int i = 0; i < q; i++)
        cout << rangeAnd(queries[i][0],
                         queries[i][1])
             << endl;
  
    return 0;
}


Java
// Java implementation of the approach 
import java.io.*;
  
class GFG 
{
      
static int MAX = 100000;
static int bitscount =32;
  
// Array to store bit-wise
// prefix count
static int [][]prefix_count = new int [bitscount][MAX];
  
// Function to find the prefix sum
static void findPrefixCount(int arr[], int n)
{
  
    // Loop for each bit
    for (int i = 0; i < bitscount; i++) 
    {
  
        // Loop to find prefix count
        prefix_count[i][0] = ((arr[0] >> i) & 1);
        for (int j = 1; j < n; j++) 
        {
            prefix_count[i][j] = ((arr[j] >> i) & 1);
            prefix_count[i][j] += prefix_count[i][j - 1];
        }
    }
}
  
// Function to answer query
static int rangeAnd(int l, int r)
{
  
    // 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 x;
        if (l == 0)
            x = prefix_count[i][r];
        else
            x = prefix_count[i][r]
                - prefix_count[i][l - 1];
  
        // Condition for ith bit
        // of answer to be set
        if (x == r - l + 1)
            ans = (ans | (1 << i));
    }
  
    return ans;
}
  
// Driver code
public static void main (String[] args) 
{
  
    int arr[] = { 7, 5, 3, 5, 2, 3 };
    int n = arr.length;
      
    findPrefixCount(arr, n);
      
    int queries[][] = { { 1, 3 }, { 4, 5 } };
    int q = queries.length;
      
    for (int i = 0; i < q; i++)
                System.out.println (rangeAnd(queries[i][0],queries[i][1]));
          
  
}
}
  
// This code is contributed by ajit.


Python3
# Python3 implementation of the approach 
  
import numpy as np
  
MAX = 100000
bitscount = 32
  
# Array to store bit-wise 
# prefix count 
prefix_count = np.zeros((bitscount,MAX)); 
  
# Function to find the prefix sum 
def findPrefixCount(arr, n) :
  
    # Loop for each bit 
    for i in range(0, bitscount) :
          
        # Loop to find prefix count 
        prefix_count[i][0] = ((arr[0] >> i) & 1); 
          
        for j in range(1, n) :
            prefix_count[i][j] = ((arr[j] >> i) & 1); 
            prefix_count[i][j] += prefix_count[i][j - 1]; 
  
# Function to answer query 
def rangeOr(l, r) : 
  
    # 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 
        x = 0; 
          
        if (l == 0) :
            x = prefix_count[i][r]; 
        else :
            x = prefix_count[i][r] - prefix_count[i][l - 1];
              
        # Condition for ith bit
        # of answer to be set
        if (x == r - l + 1) :
            ans = (ans | (1 << i)); 
              
    return ans; 
  
  
# Driver code 
if __name__ == "__main__" : 
  
    arr = [ 7, 5, 3, 5, 2, 3 ]; 
    n = len(arr);
  
    findPrefixCount(arr, n); 
  
    queries = [ [ 1, 3 ], [ 4, 5 ] ]; 
      
    q = len(queries); 
  
    for i in range(q) :
        print(rangeOr(queries[i][0], queries[i][1]));
  
  
# This code is contributed by AnkitRai01


C#
// C# implementation of the approach
using System;
  
class GFG 
{ 
      
static int MAX = 100000; 
static int bitscount =32; 
  
// Array to store bit-wise 
// prefix count 
static int [,]prefix_count = new int [bitscount,MAX]; 
  
// Function to find the prefix sum 
static void findPrefixCount(int []arr, int n) 
{ 
  
    // Loop for each bit 
    for (int i = 0; i < bitscount; i++) 
    { 
  
        // Loop to find prefix count 
        prefix_count[i,0] = ((arr[0] >> i) & 1); 
        for (int j = 1; j < n; j++) 
        { 
            prefix_count[i,j] = ((arr[j] >> i) & 1); 
            prefix_count[i,j] += prefix_count[i,j - 1]; 
        } 
    } 
} 
  
// Function to answer query 
static int rangeAnd(int l, int r) 
{ 
  
    // 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 x; 
        if (l == 0) 
            x = prefix_count[i,r]; 
        else
            x = prefix_count[i,r] 
                - prefix_count[i,l - 1]; 
  
        // Condition for ith bit 
        // of answer to be set 
        if (x == r - l + 1) 
            ans = (ans | (1 << i)); 
    } 
  
    return ans; 
} 
  
// Driver code 
public static void Main (String[] args) 
{ 
  
    int []arr = { 7, 5, 3, 5, 2, 3 }; 
    int n = arr.Length; 
      
    findPrefixCount(arr, n); 
      
    int [,]queries = { { 1, 3 }, { 4, 5 } }; 
    int q = queries.GetLength(0); 
      
    for (int i = 0; i < q; i++) 
            Console.WriteLine(rangeAnd(queries[i,0],queries[i,1])); 
          
} 
} 
  
// This code contributed by Rajput-Ji


输出:
1
2

预计算的时间复杂度为O(n),每个查询都可以在O(1)中回答