mirror of
https://github.com/TheAlgorithms/Python.git
synced 2024-10-06 05:39:30 +00:00
3d6f3c4188
* Create sparse_table.py * [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci * Descriptive names for variables * Fix ruff check error * Update sparse_table.py * Add comments, change variable names * [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci * Fix typo * Update sparse_table.py --------- Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com> Co-authored-by: Christian Clauss <cclauss@me.com>
95 lines
3.3 KiB
Python
95 lines
3.3 KiB
Python
"""
|
|
Sparse table is a data structure that allows answering range queries on
|
|
a static number list, i.e. the elements do not change throughout all the queries.
|
|
|
|
The implementation below will solve the problem of Range Minimum Query:
|
|
Finding the minimum value of a subset [L..R] of a static number list.
|
|
|
|
Overall time complexity: O(nlogn)
|
|
Overall space complexity: O(nlogn)
|
|
|
|
Wikipedia link: https://en.wikipedia.org/wiki/Range_minimum_query
|
|
"""
|
|
from math import log2
|
|
|
|
|
|
def build_sparse_table(number_list: list[int]) -> list[list[int]]:
|
|
"""
|
|
Precompute range minimum queries with power of two length and store the precomputed
|
|
values in a table.
|
|
|
|
>>> build_sparse_table([8, 1, 0, 3, 4, 9, 3])
|
|
[[8, 1, 0, 3, 4, 9, 3], [1, 0, 0, 3, 4, 3, 0], [0, 0, 0, 3, 0, 0, 0]]
|
|
>>> build_sparse_table([3, 1, 9])
|
|
[[3, 1, 9], [1, 1, 0]]
|
|
>>> build_sparse_table([])
|
|
Traceback (most recent call last):
|
|
...
|
|
ValueError: empty number list not allowed
|
|
"""
|
|
if not number_list:
|
|
raise ValueError("empty number list not allowed")
|
|
|
|
length = len(number_list)
|
|
# Initialise sparse_table -- sparse_table[j][i] represents the minimum value of the
|
|
# subset of length (2 ** j) of number_list, starting from index i.
|
|
|
|
# smallest power of 2 subset length that fully covers number_list
|
|
row = int(log2(length)) + 1
|
|
sparse_table = [[0 for i in range(length)] for j in range(row)]
|
|
|
|
# minimum of subset of length 1 is that value itself
|
|
for i, value in enumerate(number_list):
|
|
sparse_table[0][i] = value
|
|
j = 1
|
|
|
|
# compute the minimum value for all intervals with size (2 ** j)
|
|
while (1 << j) <= length:
|
|
i = 0
|
|
# while subset starting from i still have at least (2 ** j) elements
|
|
while (i + (1 << j) - 1) < length:
|
|
# split range [i, i + 2 ** j] and find minimum of 2 halves
|
|
sparse_table[j][i] = min(
|
|
sparse_table[j - 1][i + (1 << (j - 1))], sparse_table[j - 1][i]
|
|
)
|
|
i += 1
|
|
j += 1
|
|
return sparse_table
|
|
|
|
|
|
def query(sparse_table: list[list[int]], left_bound: int, right_bound: int) -> int:
|
|
"""
|
|
>>> query(build_sparse_table([8, 1, 0, 3, 4, 9, 3]), 0, 4)
|
|
0
|
|
>>> query(build_sparse_table([8, 1, 0, 3, 4, 9, 3]), 4, 6)
|
|
3
|
|
>>> query(build_sparse_table([3, 1, 9]), 2, 2)
|
|
9
|
|
>>> query(build_sparse_table([3, 1, 9]), 0, 1)
|
|
1
|
|
>>> query(build_sparse_table([8, 1, 0, 3, 4, 9, 3]), 0, 11)
|
|
Traceback (most recent call last):
|
|
...
|
|
IndexError: list index out of range
|
|
>>> query(build_sparse_table([]), 0, 0)
|
|
Traceback (most recent call last):
|
|
...
|
|
ValueError: empty number list not allowed
|
|
"""
|
|
if left_bound < 0 or right_bound >= len(sparse_table[0]):
|
|
raise IndexError("list index out of range")
|
|
|
|
# highest subset length of power of 2 that is within range [left_bound, right_bound]
|
|
j = int(log2(right_bound - left_bound + 1))
|
|
|
|
# minimum of 2 overlapping smaller subsets:
|
|
# [left_bound, left_bound + 2 ** j - 1] and [right_bound - 2 ** j + 1, right_bound]
|
|
return min(sparse_table[j][right_bound - (1 << j) + 1], sparse_table[j][left_bound])
|
|
|
|
|
|
if __name__ == "__main__":
|
|
from doctest import testmod
|
|
|
|
testmod()
|
|
print(f"{query(build_sparse_table([3, 1, 9]), 2, 2) = }")
|