Number of elements greater than K in the range L to R using Fenwick Tree (Offline queries)

The Fenwick Tree, also known as a Binary Indexed Tree (BIT), is a data structure that is primarily used for executing dynamic cumulative frequency searches on arrays in an effective manner. It's very useful for range-based computations, especially when the dataset is static or updated infrequently. The Fenwick Tree is useful for computing the number of elements greater than a specified value inside a given range [L, R].

What exactly is a Fenwick Tree?

The Fenwick Tree is a flexible data structure that may be used to do efficient prefix sum computations over an array. It is designed for cumulative frequency operations, with logarithmic time complexity for updates and queries. Its ease of use and efficiency make it a popular choice for dealing with range-based operations in a variety of programming challenges.

Structure and Construction:

The construction of a Fenwick Tree entails storing cumulative amounts at various points along the tree. The following steps are done to build the Fenwick Tree for an array of size N:

Initialization: To begin, make an array of N+1 zeros. This array will be the foundation for building the Fenwick Tree.

Construction: Traverse the original array and update the Fenwick Tree by adding items as needed. The tree is modified depending on the binary encoding of the index, with bitwise operations used to browse and update tree nodes effectively.

Query Operations

The Fenwick Tree is well-suited for range-based searches, particularly prefix sum queries. The algorithm for executing a prefix sum query is rather simple.

Query: To compute the cumulative total in the original array up to a certain index 'i,' traverse the Fenwick Tree, taking into account suitable intervals depending on 'i's binary representation. To get the required outcome, add these intervals together.

Algorithm

Sorting queries: Sort the queries in non-descending order depending on the 'R' value.
Fenwick Tree Initialization: Create a Fenwick Tree for the supplied array.
Initialise Result Array: Create an array that will hold the results of each query.
Process Queries: Go through the sorted queries and use the Fenwick Tree to count the number of entries in the range [L, R] that are greater than 'K.' Update the result array as needed.
Results: Display the results of all queries.

Pseudocode

Function countElementsGreaterThanKInRange(arr[], N, queries[][]):
    Sort queries based on queries[i][1] in non-decreasing order
    Construct Fenwick Tree using arr[]
    Initialize the result array to store the count of elements greater than K in the range [L, R]
    For each query in queries:
        L = query[0]
        R = query[1]
        K = query[2]
        count = 0
        while R > 0:
            count += FenwickTree[R]
            R -= R & (-R)
        while L > 0:
            count -= FenwickTree[L - 1]
            L -= L & (-L)
        resultArray.append(count)
    Return resultArray

Implementation

class FenwickTree:
    def __init__(self, size):
        self.size = size
        self.bit = [0] * (size + 1)

    def update(self, idx, val):
        while idx <= self.size:
            self.bit[idx] += val
            idx += idx & -idx
    def query(self, idx):
        result = 0
        while idx > 0:
            result += self.bit[idx]
            idx -= idx & -idx
        return result
def count_elements_greater_than_k(arr, queries):
    max_val = max(max(queries, key=lambda x: x[1])[1], len(arr))
    fenwick = FenwickTree(max_val)
    result = []
    queries.sort(key=lambda x: x[1])
    for query in queries:
        L, R, K = query
        count = fenwick.query(R) - fenwick.query(L - 1)
        result.append(count)
        fenwick.update(arr[L - 1], 1)  
    return result
arr = [3, 2, 7, 6, 5, 1, 4]
queries = [[2, 5, 3], [1, 6, 4], [3, 4, 2]]
result = count_elements_greater_than_k(arr, queries)
print("Result:", result)

Output:

Number of elements greater than K in the range L to R using Fenwick Tree (Offline queries)

Explanation

FenwickTree is a class representing a Fenwick Tree data structure.
__init__(self, size): Initializes the Fenwick Tree with a given size and creates a Binary Indexed Tree (BIT) array (self.bit) of size + 1 with elements initialized to zero.
update(self, idx, val): Updates the Fenwick Tree by adding val to the element at index idx and propagating the update through the tree based on the Binary Indexed Tree logic.
query(self, idx): Retrieves the cumulative sum up to the index idx in the Fenwick Tree by summing elements based on the Binary Indexed Tree logic.
count_elements_greater_than_k(arr, queries): This function takes an array arr and a list of queries.
It initializes a Fenwick Tree fenwick with a size determined by the maximum value of R in the queries or the length of the array, whichever is greater.
The function sorts the queries based on their R values (the upper bound of the range).
For each query [L, R, K] in the sorted order:

It calculates the count of elements greater than 'K' in the range [L, R] by subtracting the cumulative sums at indices R and L - 1 in the Fenwick Tree.

It updates the Fenwick Tree by incrementing the count of the element at index arr[L - 1].

Next TopicDetect Cycle in Graph using DSU

← prev next →