Persistent Segment Tree in Python

Persistent data structures are a powerful tool in computer science, enabling us to maintain and access multiple versions of a data structure over time. One such structure is the Persistent Segment Tree. Segment trees are versatile data structures that allow efficient querying and updating of array intervals. By making a segment treepersistent, we enhance its capability to maintain historical versions, which is particularly useful in competitive programming and real-time applications where rollback and point-in-time queries are needed. This article explores the concept, implementation in Python.

What is Persistent Segment Tree?

Persistence in data structures refers to the ability to maintain access to previous versions of the data structure even after modifications. This can be achieved using techniques such as path copying, where only the parts of the structure that need to be changed are copied, thus saving space and time.

Representation of Persistent Segment Tree:

Each node in a Persistent Segment Tree contains:

• Value: The value stored at this node, which typically represents an aggregate (like sum, min, or max) over a segment of the array.
• Left: A reference to the left child node.
• Right: A reference to the right child node.

Persistent Segment Tree Operations

Persistent Segment Trees allow you to perform updates and queries efficiently while preserving the history of changes. Here are the primary operations you can perform on a Persistent Segment Tree:

1. Build: Construct the initial segment tree from an array.
2. Update: Create a new version of the tree with an updated value at a specific index.
3. Query: Perform range queries on any version of the tree.

1. Building the Initial Segment Tree

The build function constructs the segment tree from an array. This is similar to building a regular segment tree but sets up the foundation for persistence.

Algorithm:

1. If the current segment is a single element (i.e., left == right), create a leaf node with the value of that element.
2. Otherwise, split the segment into two halves and recursively build the left and right subtrees.
3. Create a new node whose value is the sum (or other aggregate function) of the values of the left and right children.

Implementation:

2. Updating the Segment Tree Persistently

The update function creates a new version of the segment tree by copying only the necessary parts. It returns a new root node for the updated version, leaving the previous versions intact.

Algorithm:

1. If the current segment is a single element (i.e., left == right), create a new node with the updated value.
2. Otherwise, determine whether the index to be updated lies in the left or right subtree.
3. Recursively update the relevant subtree while keeping the other subtree unchanged.
4. Create a new node whose value is the sum (or other aggregate function) of the values of the updated left and right children.

Implementation:

3. Querying the Segment Tree

The query function retrieves information from a segment of the tree. It can perform range queries on any version of the tree.

Algorithm:

1. If the query range does not overlap with the current segment, return 0 (or the identity value for the aggregate function).
2. If the current segment is completely within the query range, return the value of the current node.
3. Otherwise, split the query range and recursively query the left and right subtrees.
4. Return the sum (or other aggregate function) of the results of the left and right subtree queries.

Implementation:

Illustration of working of Persistent Segment Tree in Python:

Let's walk through a detailed example step-by-step to illustrate how the persistent segment tree works:

Initial Array

• arr = [1,2,3,4,5]

Building the Initial Segment Tree

1. Build the leaf nodes:
   • Leaf node for arr[0]: value = 1
   • Leaf node for arr[1]: value = 2
   • Leaf node for arr[2]: value = 3
   • Leaf node for arr[3]: value = 4
   • Leaf node for arr[4]: value = 5
2. Build the internal nodes:
   • Node for range [0, 1]: value = 1 + 2 = 3
   • Node for range [2, 2]: value = 3
   • Node for range [3, 4]: value = 4 + 5 = 9
   • Node for range [0, 2]: value = 3 + 3 = 6
   • Node for range [0, 4]: value = 6 + 9 = 15

Updating the Segment Tree

1. Update arr[2] from 3 to 10:
   • Create new leaf node for arr[2]: value = 10
   • Update node for range [2, 2]: new value = 10
   • Update node for range [0, 2]: new value = 3 + 10 = 13
   • Update node for range [0, 4]: new value = 13 + 9 = 22

Querying the Segment Tree

1. Query range [1, 3] in the original tree:
   • Node for range [1, 3] overlaps with range [0, 4], [0, 2], and [3, 4]
   • Query range [1, 3] results in sum = 2 + 3 + 4 = 9
2. Query range [1, 3] in the updated tree:
   • Node for range [1, 3] overlaps with range [0, 4], [0, 2], and [3, 4]
   • Query range [1, 3] results in sum = 2 + 10 + 4 = 16

This example demonstrates how the persistent segment tree maintains different versions efficiently and supports range queries on any version.

Implementation of Persistent segment trees in Python

Below is the complete implementation of a Persistent Segment Tree in Python:

9
16

Complexity Analysis of Persistent Segment Tree: