Sparse Table

Introduction

One frequently runs into issues with handling large amounts of data and effectively performing range queries in the world of data structures and algorithms. An elegant and effective data structure called the "Sparse Table" offers a solution to this kind of issue. In this article, we will examine the sparse table concept, its Python implementation, some use cases, and performance evaluation.

What is a Sparse Table?

A data structure called a sparse table helps static array or list range queries perform better. In order to efficiently respond to queries, it precalculates and stores particular data from the original array. A Sparse Table's main concept is to divide an array into overlapping blocks and precompute the most frequent queries' responses within each block.

Benefits of a Sparse Table

Compared to naive methods of handling range queries, sparse tables have a number of benefits. Among the main advantages are:

Efficient Range Queries: Sparse Tables make it possible to quickly perform any associative operation, such as finding the sum, minimum, or maximum. The precomputed data enables logarithmic time query resolution.
Static Data: The Sparse Table is the best option for static data scenarios where the array does not change frequently because, once built, its structure is fixed.
Simplicity: A Sparse Table can easily be modified to fit a variety of problem scenarios and is relatively easy to implement.

Sparse Table Python Implementation

Initialization of the sparse table

Prior to creating the sparse table, we must initialise the required data structures and determine the necessary table size.

# Python code for Sparse Table initialization
def initialize_s_table(arr):
    n = len(arr)
    k = int(log2(n)) + 1
    s_table = [[0] * k for _ in range(n)]
    return s_table, k

Building the Sparse Table

Fill the Sparse Table with the data that has already been pre-calculated for range queries.

def build_s_table(arr, s_table, n, k):
    for i in range(n):
        s_table[i][0] = arr[i]

    j = 1
    while (1 << j) <= n:
        i = 0
        while (i + (1 << j)) <= n:
            s_table[i][j] = min(s_table[i][j - 1], s_table[i + (1 << (j - 1))][j - 1])
            i += 1
        j += 1

Querying the Sparse Table

Using the precomputed values from the sparse table, we can quickly respond to range queries.

def query_s_table(s_table, l, r):
    j = int(log2(r - l + 1))
    minimum = min(s_table[l][j], s_table[r - (1 << j) + 1][j])
    return minimum

Complete code is as follows:

import math
 
def buildSparseTable(arr, n): 
    for i in range(0, n):
        lookup[i][0] = arr[i]
    j = 1
    while (1 << j) <= n:
        i = 0
        while (i + (1 << j) - 1) < n:
            if (lookup[i][j - 1] <
                lookup[i + (1 << (j - 1))][j - 1]):
                lookup[i][j] = lookup[i][j - 1]
            else:
                lookup[i][j] = \
                        lookup[i + (1 << (j - 1))][j - 1]
             
            i += 1
        j += 1       
def query(L, R):
    j = int(math.log2(R - L + 1))
    if lookup[L][j] <= lookup[R - (1 << j) + 1][j]:
        return lookup[L][j] 
    else:
        return lookup[R - (1 << j) + 1][j]
if __name__ == "__main__":
    a = [7, 2, 3, 0, 5, 10, 3, 12, 18]
    n = len(a)
    MAX = 500
    lookup = [[0 for i in range(MAX)]
                 for j in range(MAX)]
    buildSparseTable(a, n)
    print(query(0, 4))
    print(query(4, 7))
    print(query(7, 8))

Output:

0
3
12

Here's an explanation of the code:

The buildSparseTable function takes two arguments: arr (the input array) and n (the size of the array). It initializes the sparse table with the minimum values for all single-element ranges.
Inside the buildSparseTable function, a nested loop structure is used to calculate and store the minimum values for ranges of different lengths using the concept of binary lifting.
The outer loop iterates through the possible values of j, which represents the length of the ranges being considered (powers of 2).
The inner loop iterates through the array indices i. For each index, the value of lookup[i][j] is calculated based on the minimum value between two smaller ranges: lookup[i][j - 1] (the value from the previous smaller range) and lookup[i + (1 << (j - 1))][j - 1] (the value from the next smaller range, starting after 2^(j-1) elements from index i).
The query function takes two arguments L and R (representing the left and right indices of the query range) and returns the minimum value within that range using the sparse table.
Inside the query function, the value of j is calculated as the floor of the base-2 logarithm of the query range length (R - L + 1).
The minimum value within the query range is obtained by comparing the minimum value in two adjacent smaller ranges, either from the left or the right side of the query range, based on which one has the smaller minimum value.
In the example usage section, an array a is defined, and its length n is calculated. A 2D array lookup is initialized to store the precomputed minimum values for different ranges. The buildSparseTable function is called to populate the lookup
The query function is used to answer range minimum queries for different ranges within the array. The results of these queries are printed.

Examples of Sparse Table Use

Sparse Tables are useful in many situations, including the following:

Range Sum Queries

We can quickly determine the sum of the elements in a range [l, r] given an array by using a sparse table.

Minimum/Maximum Range Queries

The minimum or maximum element in a given range can be found using sparse tables in logarithmic time.

Longest Common Prefix

The most effective method for determining the longest common prefix between two array elements is to use sparse tables.

Time and Space Complexity Analysis

Due to the precomputed values, querying a range only requires O(1) time when building the sparse table, which has an O(N log N) time complexity. The table's storage causes the space complexity to be O(N log N).

Comparison with Other Data Structures

Sparse Tables are simpler and simpler to implement when compared to other range query data structures like Segment Trees or Fenwick Trees. They might not, however, be as adaptable when dealing with scenarios involving dynamic data.

Next TopicSquare Root (Sqrt) Decomposition Algorithm

← prev next →