Fenwick Range Queries 🎯

Welcome to our deep dive into Fenwick Range Queries! This lesson is designed for both beginners and intermediates who are eager to explore the world of data structures and algorithms. 📝

What are Fenwick Range Queries? 💡

Fenwick Range Queries, also known as Binary Indexed Tree or Segment Tree, is a data structure used to efficiently perform range queries and updates on a given array. It's a powerful tool in solving problems that involve range sum, range minimum, and range maximum queries.

Why Use Fenwick Range Queries? 💡

Efficient: Fenwick Range Queries provide an O(log n) solution for range queries, making them extremely efficient for large datasets.
Flexible: They can be used to solve a variety of problems, including finding the sum, minimum, and maximum values in a range.
Space-Efficient: The space complexity is O(n) for both the Fenwick Tree and the original array.

Understanding Fenwick Tree 💡

A Fenwick Tree is a binary tree data structure that stores the cumulative sum of elements in an array. Each node in the tree stores the sum of elements from itself to the leaf it represents.

Fenwick Tree Structure

Building a Fenwick Tree 💡

To build a Fenwick Tree, we'll follow these steps:

Initialize an array of size n+1 with all elements as 0. The extra element is used to represent the sum of the entire array.
For each element i from 1 to n, update the parent nodes of i in the tree by adding the value of i to them.

Range Queries and Updates 💡

Range Query (Sum, Min, Max)

To find the sum, minimum, or maximum of a range [L, R], we'll follow these steps:

Calculate the sum, minimum, or maximum of the root node.
If L > 1, update the sum, minimum, or maximum for the node representing L-1.
Continue this process until L is 1.
Repeat the process from step 1 for the node representing R+1.
Sum up the results from steps 1 and 4 to get the final answer.

Range Update

To update a value in the range [L, R], we'll follow these steps:

Update the value of the element L with the new value.
Update the parent nodes of L in the tree according to the new value.
If L < R, update the value of the element R with the new value and repeat the process from step 2 for the parent nodes of R.

Practical Example 💡

Let's consider an array [3, 5, 2, 1, 7, 4, 9]. After building the Fenwick Tree, we can:

Find the sum of the range [2, 4] = 14 (3+5+2)
Update the value of the element at index 3 to 6
Find the new sum of the range [2, 4] = 16 (3+5+2+6)

Advanced Example 💡

In a real-world project, Fenwick Range Queries can be used to solve problems like:

Calculating the number of subarrays with a sum greater than a given value
Finding the kth smallest element in an array
Solving range queries with constraints like range sum should be even or greater than a given value

Wrapping Up 📝

Fenwick Range Queries is a powerful data structure that can help you solve a variety of problems efficiently. With practice, you'll be able to leverage its capabilities in your projects and code challenges. Happy coding! 💻✅

Here's a complete working example of a Fenwick Tree implementation in Python:

python

def build_fenwick_tree(arr):
    n = len(arr)
    fenwick_tree = [0] * (n + 1)

    for i in range(1, n + 1):
        fenwick_tree[i] = arr[i - 1]
        for j in range(i, n + 1, i):
            fenwick_tree[j] += fenwick_tree[j - i]

    return fenwick_tree

def range_sum(fenwick_tree, l, r):
    return sum(fenwick_tree[r + 1]) - sum(fenwick_tree[l])

def update(fenwick_tree, i, val):
    for j in range(i, len(fenwick_tree) + 1, i):
        fenwick_tree[j] += val

def build_and_update(arr, i, val):
    fenwick_tree = build_fenwick_tree(arr)
    update(fenwick_tree, i, val)
    return fenwick_tree

Happy learning and coding! 🤖🚀💻