Let $f$ be some group operation (a binary associative function over a set with an identity element and inverse elements) and $A$ be an array of integers of length $N$.

Denote $f$'s infix notation as $\*$; that is, $f(x,y) = x\*y$ for arbitrary integers $x,y$.

(Since this is associative, we will omit parentheses for order of application of $f$ when using infix notation.)

The Fenwick tree is a data structure which:

* calculates the value of function $f$ in the given range $[l, r]$ $\left(\text{i.e. }A_l \* A_{l+1} \* \dots \* A_r)\right)$ in $O(\log N)$ time

* updates the value of an element of $A$ in $O(\log N)$ time

* requires $O(N)$ memory (the same amount required for $A$)

* is easy to use and code, especially in the case of multidimensional arrays

The most common application of a Fenwick tree is _calculating the sum of a range_.

For example, using addition over the set of integers as the group operation, i.e. $f(x,y) = x + y$: the binary operation, $\*$, is $+$ in this case, so $A_l \* A_{l+1} \* \dots \* A_r = A_l + A_{l+1} + \dots + A_{r}$.

(In terms of $f$, this would be $f(A_l, f(A_{l+1}, f(f(\dots, \dots),A_r)))$, or any other equivalent way to write this using associativity.)

The Fenwick tree is also called a **Binary Indexed Tree** (BIT).

It was first described in a paper titled "A new data structure for cumulative frequency tables" (Peter M. Fenwick, 1994).

For the sake of simplicity, we will assume that function $f$ is defined as $f(x,y) = x + y$ over the integers.

Suppose we are given an array of integers, $A[0 \dots N-1]$.

(Note that we are using zero-based indexing.)

A Fenwick tree is just an array, $T[0 \dots N-1]$, where each element is equal to the sum of elements of $A$ in some range, $[g(i), i]$:

We will define $g$ in the next few paragraphs.

The data structure is called a tree because there is a nice representation of it in the form of a tree, although we don't need to model an actual tree with nodes and edges.

We only need to maintain the array $T$ to handle all queries.

Many people use a version of the Fenwick tree that uses one-based indexing.

As such, you will also find an alternative implementation which uses one-based indexing in the implementation section.

Now we can write some pseudo-code for the two operations mentioned above.

Below, we get the sum of elements of $A$ in the range $[0, r]$ and update (increase) some element $A_i$:

1. First, it adds the sum of the range $[g(r), r]$ (i.e. $T[r]$) to the `result`.

2. Then, it "jumps" to the range $[g(g(r)-1), g(r)-1]$ and adds this range's sum to the `result`.

3. This continues until it "jumps" from $[0, g(g( \dots g(r)-1 \dots -1)-1)]$ to $[g(-1), -1]$; this is where the `sum` function stops jumping.

The function `increase` works with the same analogy, but it "jumps" in the direction of increasing indices:

1. Sums of the range $[g(j), j]$ which satisfy the condition $g(j) \le i \le j$ are increased by `delta`; that is, `t[j] += delta`.

Therefore, it updates all elements in $T$ that correspond to ranges in which $A_i$ lies.

The complexity of both `sum` and `increase` depend on the function $g$.

There are many ways to choose the function $g$ such that $0 \le g(i) \le i$ for all $i$.

For instance, the function $g(i) = i$ works, which yields $T = A$ (in which case, the summation queries are slow).

We could also take the function $g(i) = 0$.

This would correspond to prefix sum arrays (in which case, finding the sum of the range $[0, i]$ will only take constant time; however, updates are slow).

The clever part of the algorithm for Fenwick trees is how it uses a special definition of the function $g$ which can handle both operations in $O(\log N)$ time.