Queries for Sum of Bitwise AND of all Subarrays in a Range

Given an array arr[] of size N, the task is to answer a set of Q queries, each in the format of queries[i][0] and queries[i][1]. For each queries[i], find the sum of Bitwise AND of all subarrays whose elements lie in the range [queries[i][0], queries[i][1]].

Examples:

Input: N = 3, arr[] = {1, 0, 2}, Q = 2, queries[][] = {{1, 2}, {2, 3}}
Output: 1 2
Explanation:

• For the first query AND[1] + AND[0] + AND[1, 0] = 1.
• For the second query AND[0] + AND[2] + AND[0, 2] = 2.

Input: N = 4, arr[] = {4, 3, 2, 1}, Q = 3, queries[][] = {{1, 3}, {2, 4}, {1, 4}}
Output: 11 8 12
Explanation:

• For the first query AND[4] + AND[3] + AND[2] + AND[4, 3] + AND[4, 3, 2] + AND[3, 2] = 11.
• For the second query AND[3] + AND[2] + AND[1] + AND[3, 2] + AND[3, 2, 1] + AND[2, 1] = 8.
• For the third query AND[4] + AND[3] + AND[2] + AND[1] + AND[4, 3] + AND[4, 3, 2] + AND[4, 3, 2, 1] + AND[3, 2] + AND[3, 2, 1] + AND[2, 1] = 12.

Approach: This can be solved with the following idea:

The main idea is to use precomputation to optimize the Bitwise AND calculation for subarrays. This is achieved by maintaining arrays that store the count and cumulative sum of consecutive set bits in the binary representation of the array elements. The final result is computed by considering the contributions of each bit position separately.

Step-by-step algorithm:

• Create two 2D arrays, pref[20][N] and next[20][N] where N is the length of array arr[].
• pref[j][i] will store the count and cumulative sum of set bits in the binary representation of arr[i] at bit position j.
• next[j][i] will store the next index with a set bit to the right of index i.
• Iterate Through Bits and Array Elements, for each bit position j from 0 to 19:
  • Calculate the count of set bits at bit position j in arr[i].
  • Update pref[j][i] with the count and cumulative sum of set bits.
  • Update next[j][i] with the next index having a set bit to the right of index i.
• Iterate through each bit position j (from 0 to 19) and calculate the values for pref[][] and next[][] based on the binary representation of array elements.
• Initialize an empty vector ans to store the results.
• For each query [u, v], iterate through each bit position j and compute the contribution of the set bits at position j within the subarray [u, v]. Update the result by adding the contribution multiplied by 2^j.
• Append the final result to the ans vector.
• Return the ans vector containing the results for all queries.

Below is the implementation of the algorithm:

C++

#include <bits/stdc++.h>
using namespace std;

// Function to find sum of AND
vector<long long> summationOfAnd(int N, vector<int>& arr,
                                int Q,
                                vector<vector<int> >& queries)
{

    // Declare a 2D vector
    vector<vector<pair<int, int> > > pref(
        20, vector<pair<int, int> >(N));
    vector<vector<int> > next(20, vector<int>(N, 0));

    // Start Iterating
    for (int j = 0; j < 20; j++) {

        int curr = 0, sum = 0;

        // Iterate in array
        for (int i = 0; i < N; i++) {

            // Get the AND value
            if ((arr[i] & (1 << j)) > 0) {
                curr++;
                sum += curr;
                pref[j][i] = { curr, sum };
            }
            else {

                // If curr value is greater than 0
                if (curr > 0) {
                    next[j][i - 1] = i - 1;
                }

                // Set the value to 0
                // for next iteration
                curr = 0;
                pref[j][i] = { curr, sum };
            }
        }

        // Update the value in next vector
        next[j][N - 1] = N - 1;

        // Start Iterating from n -2
        for (int i = N - 2; i >= 0; i--) {
            if (next[j][i] == 0) {
                next[j][i] = next[j][i + 1];
            }
        }
    }
    vector<long long> ans;
    // Iterate in B
    for (int i = 0; i < Q; i++) {

        int u = queries[i][0] - 1;
        int v = queries[i][1] - 1;
        long long res = 0;

        // Iterate again for 20 times
        for (int j = 0; j < 20; j++) {
            long long temp;

            // Get the temp value
            if (u == 0) {
                temp = pref[j][v].second;
            }
            else if (pref[j][u].first == 0) {
                temp = pref[j][v].second - pref[j][u].second;
            }
            else {
                // Minumum value for right
                int right = min(v, next[j][u]);

                temp = pref[j][v].second
                    - pref[j][right].second;
                if (pref[j][right].first > 0) {
                    temp += (right - u + 1)
                            * (right - u + 2) / 2;
                }
            }
            // Add the value to res
            res += (temp * (1 << j));
        }

        // Store it in ans
        ans.push_back(res);
    }

    // Return vector ans
    return ans;
}

// Driver code
int main()
{

    int N = 4;
    vector<int> arr = { 4, 3, 2, 1 };
    int Q = 3;
    vector<vector<int> > queries
        = { { 1, 3 }, { 2, 4 }, { 1, 4 } };

    // Function call
    vector<long long> ans = summationOfAnd(N, arr, Q, queries);

    for (auto a : ans) {
        cout << a << " ";
    }
    return 0;
}

Java

import java.util.*;

public class Main {

    // Function to find sum of AND
    static List<Long> summationOfAnd(int N, List<Integer> arr, int Q, List<List<Integer>> queries) {

        // Declare a 2D vector
        List<List<Pair>> pref = new ArrayList<>(20);
        List<List<Integer>> next = new ArrayList<>(20);
        for (int i = 0; i < 20; i++) {
            pref.add(new ArrayList<>(Collections.nCopies(N, new Pair(0, 0))));
            next.add(new ArrayList<>(Collections.nCopies(N, 0)));
        }

        // Start iterating
        for (int j = 0; j < 20; j++) {
            int curr = 0, sum = 0;

            // Iterate in array
            for (int i = 0; i < N; i++) {
                // Get the AND value
                if ((arr.get(i) & (1 << j)) > 0) {
                    curr++;
                    sum += curr;
                    pref.get(j).set(i, new Pair(curr, sum));
                } else {
                    // If curr value is greater than 0
                    if (curr > 0) {
                        next.get(j).set(i - 1, i - 1);
                    }
                    // Set the value to 0 for next iteration
                    curr = 0;
                    pref.get(j).set(i, new Pair(curr, sum));
                }
            }
            // Update the value in next list
            next.get(j).set(N - 1, N - 1);

            // Start Iterating from n -2
            for (int i = N - 2; i >= 0; i--) {
                if (next.get(j).get(i) == 0) {
                    next.get(j).set(i, next.get(j).get(i + 1));
                }
            }
        }
        List<Long> ans = new ArrayList<>();
        // Iterate in B
        for (List<Integer> query : queries) {
            int u = query.get(0) - 1;
            int v = query.get(1) - 1;
            long res = 0;
            // Iterate again for 20 times
            for (int j = 0; j < 20; j++) {
                long temp;
                // Get the temp value
                if (u == 0) {
                    temp = pref.get(j).get(v).second;
                } else if (pref.get(j).get(u).first == 0) {
                    temp = pref.get(j).get(v).second - pref.get(j).get(u).second;
                } else {
                    // Minimum value for right
                    int right = Math.min(v, next.get(j).get(u));
                    temp = pref.get(j).get(v).second - pref.get(j).get(right).second;
                    if (pref.get(j).get(right).first > 0) {
                        temp += (right - u + 1) * (right - u + 2) / 2;
                    }
                }
                // Add the value to res
                res += (temp * (1L << j));
            }
            // Store it in ans
            ans.add(res);
        }
        // Return list ans
        return ans;
    }

    // Pair class to store pair values
    static class Pair {
        int first;
        int second;

        Pair(int first, int second) {
            this.first = first;
            this.second = second;
        }
    }

    // Driver code
    public static void main(String[] args) {

        int N = 4;
        List<Integer> arr = Arrays.asList(4, 3, 2, 1);
        int Q = 3;
        List<List<Integer>> queries = Arrays.asList(Arrays.asList(1, 3), Arrays.asList(2, 4), Arrays.asList(1, 4));

        // Function call
        List<Long> ans = summationOfAnd(N, arr, Q, queries);

        // Print the result
        for (long a : ans) {
            System.out.print(a + " ");
        }
    }
}

C#

using System;
using System.Collections.Generic;

class Solution {
    // Function to find sum of AND
    static List<long> SummationOfAnd(int N, List<int> arr, int Q, List<List<int>> queries) {
        // Declare a 2D list
        List<List<Tuple<int, int>>> pref = new List<List<Tuple<int, int>>>();
        List<List<int>> next = new List<List<int>>();

        // Initialize pref and next lists
        for (int i = 0; i < 20; i++) {
            pref.Add(new List<Tuple<int, int>>());
            next.Add(new List<int>());
            for (int j = 0; j < N; j++) {
                pref[i].Add(new Tuple<int, int>(0, 0));
                next[i].Add(0);
            }
        }

        // Start Iterating
        for (int j = 0; j < 20; j++) {
            int curr = 0, sum = 0;

            // Iterate in array
            for (int i = 0; i < N; i++) {
                // Get the AND value
                if ((arr[i] & (1 << j)) > 0) {
                    curr++;
                    sum += curr;
                    pref[j][i] = new Tuple<int, int>(curr, sum);
                }
                else {
                    // If curr value is greater than 0
                    if (curr > 0) {
                        next[j][i - 1] = i - 1;
                    }

                    // Set the value to 0 for next iteration
                    curr = 0;
                    pref[j][i] = new Tuple<int, int>(curr, sum);
                }
            }

            // Update the value in next vector
            next[j][N - 1] = N - 1;

            // Start Iterating from n -2
            for (int i = N - 2; i >= 0; i--) {
                if (next[j][i] == 0) {
                    next[j][i] = next[j][i + 1];
                }
            }
        }

        List<long> ans = new List<long>();

        // Iterate in B
        for (int i = 0; i < Q; i++) {
            int u = queries[i][0] - 1;
            int v = queries[i][1] - 1;
            long res = 0;

            // Iterate again for 20 times
            for (int j = 0; j < 20; j++) {
                long temp;

                // Get the temp value
                if (u == 0) {
                    temp = pref[j][v].Item2;
                }
                else if (pref[j][u].Item1 == 0) {
                    temp = pref[j][v].Item2 - pref[j][u].Item2;
                }
                else {
                    // Minimum value for right
                    int right = Math.Min(v, next[j][u]);
                    temp = pref[j][v].Item2 - pref[j][right].Item2;
                    if (pref[j][right].Item1 > 0) {
                        temp += (right - u + 1) * (right - u + 2) / 2;
                    }
                }
                // Add the value to res
                res += (temp * (1 << j));
            }

            // Store it in ans
            ans.Add(res);
        }

        // Return vector ans
        return ans;
    }

    // Driver code
    static void Main(string[] args) {
        int N = 4;
        List<int> arr = new List<int> { 4, 3, 2, 1 };
        int Q = 3;
        List<List<int>> queries = new List<List<int>> {
            new List<int> { 1, 3 },
            new List<int> { 2, 4 },
            new List<int> { 1, 4 }
        };

        // Function call
        List<long> ans = SummationOfAnd(N, arr, Q, queries);

        foreach (long a in ans) {
            Console.Write(a + " ");
        }
    }
}

Javascript

function GFG(N, arr, Q, queries) {
    // Declare variables
    let pref = new Array(20).fill(null).map(() => new Array(N).fill(null));
    let next = new Array(20).fill(null).map(() => new Array(N).fill(0));
    // Start Iterating
    for (let j = 0; j < 20; j++) {
        let curr = 0, sum = 0;
        // Iterate over array
        for (let i = 0; i < N; i++) {
            // Get the AND value
            if ((arr[i] & (1 << j)) > 0) {
                curr++;
                sum += curr;
                pref[j][i] = [curr, sum];
            } else {
                // If curr value is greater than 0
                if (curr > 0) {
                    next[j][i - 1] = i - 1;
                }
                curr = 0;
                pref[j][i] = [curr, sum];
            }
        }
        // Update the value in next vector
        next[j][N - 1] = N - 1;
        // Start Iterating from n -2
        for (let i = N - 2; i >= 0; i--) {
            if (next[j][i] == 0) {
                next[j][i] = next[j][i + 1];
            }
        }
    }
    
    let ans = [];
    // Iterate over queries
    for (let i = 0; i < Q; i++) {
        let u = queries[i][0] - 1;
        let v = queries[i][1] - 1;
        let res = 0;
        // Iterate again for 20 times
        for (let j = 0; j < 20; j++) {
            let temp;
            // Get the temp value
            if (u === 0) {
                temp = pref[j][v][1];
            } else if (pref[j][u][0] === 0) {
                temp = pref[j][v][1] - pref[j][u][1];
            } else {
                // Minumum value for right
                let right = Math.min(v, next[j][u]);
                temp = pref[j][v][1] - pref[j][right][1];
                if (pref[j][right][0] > 0) {
                    temp += (right - u + 1) * (right - u + 2) / 2;
                }
            }
            // Add the value to res
            res += (temp * (1 << j));
        }
        // Store it in ans
        ans.push(res);
    }
    // Return vector ans
    return ans;
}
// Driver code
function main() {
    let N = 4;
    let arr = [4, 3, 2, 1];
    let Q = 3;
    let queries = [[1, 3], [2, 4], [1, 4]];
    // Function call
    let ans = GFG(N, arr, Q, queries);
    // Print the result
    let output = "";
    for (let a of ans) {
        output += a + " ";
    }
    console.log(output.trim());  // Trim to remove trailing space
}
// Invoke main function
main();

Python3

def solve(N, arr, Q, queries):
    pref = [[[0, 0] for _ in range(N)] for _ in range(20)]
    next = [[0 for _ in range(N)] for _ in range(20)]

    for j in range(20):
        curr, sum = 0, 0
        for i in range(N):
            if arr[i] & (1 << j):
                curr += 1
                sum += curr
                pref[j][i] = [curr, sum]
            else:
                if curr > 0:
                    next[j][i - 1] = i - 1
                curr = 0
                pref[j][i] = [curr, sum]
        next[j][N - 1] = N - 1
        for i in range(N - 2, -1, -1):
            if next[j][i] == 0:
                next[j][i] = next[j][i + 1]

    ans = []
    for u, v in queries:
        u -= 1
        v -= 1
        res = 0
        for j in range(20):
            if u == 0:
                temp = pref[j][v][1]
            elif pref[j][u - 1][0] == 0:
                temp = pref[j][v][1] - pref[j][u - 1][1]
            else:
                right = min(v, next[j][u - 1])
                temp = pref[j][v][1] - pref[j][right][1]
                if pref[j][right][0] > 0:
                    temp += (right - u + 1) * (right - u + 2) // 2
            res += temp * (1 << j)
        ans.append(res)
    return ans

# Driver code
if __name__ == "__main__":
    N = 4
    arr = [4, 3, 2, 1]
    Q = 3
    queries = [(1, 3), (2, 4), (1, 4)]
    ans = solve(N, arr, Q, queries)
    for a in ans:
        print(a, end=" ")

Output

11 8 12 

Time Complexity: O(N + Q), where N is the size of input array arr[] and Q is the number of queries.
Auxiliary Space: O(N)