Lazy Propagation in Segment Tree in Java

The topic lazy propagation in segment tree in Java is the continuation of the topic segment tree in Java. Readers are advised to go through the segment tree topic first. Lazy propagation in a segment tree means postponing the updates of some values and updating them only when it is required.

Update Operation

Let's recall the update operation of a segment tree.

Begin with the root of the segment tree.
If the range of the current node does not contain the index of the input array, then return.
Else update the current node and repeat from step 2 for the children of the current node.

Lazy Propagation in Segment Tree in Java

Scenario for Lazy Propagation

Let's discuss a scenario where one should use the lazy propagation technique.

Suppose the task is to add the value 6 to each of the elements of the input array from the index 1 to 4. To do the task, one has to call the update() method for each element from index 1 to 4. These multiple calls lead to more time consumption. It is where the lazy propagation technique kicks in to make the update process fast.

Note that a node of the segment tree contains the result of a query for a range of indices. And if the range of this node lies within the range of the update operation, then all the descendants of that node have to be updated. For example, if we consider the node with the value 35 in the above diagram, then the node contains the sum of values at the indices from 3 to 5 (see the above diagram). If the query of an update is for the range 2 to 5, then we have to update that node and all the descendants of that node. Using the lazy propagation, we need to update the node with value 35 and defer the updates of its descendants by containing this information of update in the separate nodes known as lazy nodes or the values. We create an array lazy[] that represents the lazy nodes. The size of the array lazy[] is the same as the array that does the representation of the segment tree, which is t[] in the following code.

The approach is to initialize all the elements of the array lazy[] as 0. A value of 0 in the array lazy[j] shows that there are no updates pending on node j in the segment tree. Any other value (let's say the value is v) of lazy[j] means that tree before making any query to the node, v amount must be added to the node j in the segment tree.

Steps Involved in Updating a Node Using Lazy Propagation in Segment Tree

// To update the segment tree for changes in the array values 
// at the array indexes from x to y.
updateRange(us, ue)
1) If a node of the current segment tree has any update pending, then 
at first complete that pending update of that node
2) If the range of the current node lies completely in the range of the update query.
....i) Update the current node
....ii) Postpone the updates to child nodes by setting the lazy value for the child nodes.
3) If the range of the current node overlaps with the update range, then follow the same    
     approach as the above simple update.
...i) Recur for the left and the right children.
...ii) Update the current node using the results of the left and right calls.

Implementation of Lazy Propagation

Observe the following program.

FileName: LazySegTree.java

// A Java program to show the lazy propagation in the segment tree
public class LazySegTree
{
final int MAX_SIZE = 100;	 // Max tree size
int t[] = new int[MAX_SIZE]; // To store segment tree
int lazy[] = new int[MAX_SIZE]; // To store pending updates
// currNode -> index of the current node in the segment tree
//	x and y -> Start and end indices of the elements for
//	                  which the current nodes keep sum.
// 	s and e -> start and end indices of the update query
//	val -> it is the value one needs to add in the range x to y
void updateRangeUtil(int currNode, int x, int y, int s, int e, int val)
{
// If the lazy value is non-zero for the current node of the segment tree, 
// then there are some updates pending. Therefore, we need to ensure that
// that the updates pending are completed before
// making any new updates. It is because the value might get used by
// the parent after the recursive calls (Observe the last statement of this
// method)
if (lazy[currNode] != 0)
{
// Make the pending updates using the value stored in the lazy nodes
t[currNode] += (y - x + 1) * lazy[currNode];
// checking if it is not leaf node because if
// it is leaf node, then we cannot go further
if (x != y)
{
// We can defer the updating of children as we do not require
// their updated values now.
// Since we are not yet updating the children of the node si,
// it is required to set the lazy flags for its children
lazy[2 * currNode + 1] += lazy[currNode];
lazy[2 * currNode + 2] += lazy[currNode];
}
// Setting the lazy value for the current node as 0 
// as it is updated
lazy[currNode] = 0;
}
// out of the range
if (x > y || x > e || y < s)
{
return;
}
// the Current segment is completely in the range
if (x >= s && y <= e)
{
// Add the difference to current node
t[currNode] += (y - x + 1) * val;
// the same logic for checking for the leaf nodes
if (x != y)
{
// It is where the values are stored in the lazy nodes,
// rather than doing the updation on the segment tree.
// Since the updated values is not needed now,
// we can defer the updates by keeping the values in the lazy[]
lazy[2 * currNode + 1] += val;
lazy[2 * currNode + 2] += val;
}
return;
}
// If not fully in the range, but there are some overlaps, 
// recur for the children,
int mid = (x + y) / 2;
updateRangeUtil(2 * currNode + 1, x, mid, s, e, val);
updateRangeUtil(2 * currNode + 2, mid + 1, y, s, e, val);
// And using the result of the children calls the  node is getting updated
t[currNode] = t[2 * currNode + 1] + t[2 * currNode + 2];
}
// Method to update a range of values in the segment tree
// x and y -> start and end indices of the update query
// val -> it is the value one needs to add in the range x to y
void updateRange(int n, int x, int y, int val) 
{
updateRangeUtil(0, 0, n - 1, x, y, val);
}
// A recursive method to find the sum of values of the given range in the array. 
// The parameters for this method are described as: 
//	si --> The current node index of the segment tree.
//		In the beginning, 0 is passed as the root and is always at'
//		the index 0
//	x & y --> Start and end indices of the segment
//				 is shown by the current node,
//				i.e., t[si]
//	s & e --> Start and end indices of the query
//				range 
int getSumUtil(int x, int y, int s, int e, int si)
{
// If the lazy flag is set for the current node of the segment tree,
// then it means that some of the updates are pending. Therefore, we need to
// ensure that the updates pending are completed before
// the processing of the sub sum query
if (lazy[si] != 0)
{
// Make the pending updates to the node. Notice that this
// node representing the sum of elements in array a[x .. y] and
// all these elements should be incremented by lazy[si]
t[si] += (y - x + 1) * lazy[si];
// checking if it is not leaf node because if
// it is leaf node then we cannot go further
if (x != y)
{
// Since we do not need the updated values now,
// we defer the updates by keeping the values in the lazy[]
lazy[2 * si + 1] += lazy[si];
lazy[2 * si + 2] += lazy[si];
}
// set the value in the array lazy[] at the index si to zero
// it is because its value is updated
lazy[si] = 0;
}
// Out of the range
if (x > y || x > e || y < s)
{
return 0;
}
// At this point, ensure that the lazy updates that were pending are finished
// for the current node. Hence, we can return the value (the same as
// it was for the query in the topic of segment tree post)

// If this segment lies in the range
if (x >= s && y <= e)
{
return t[si];
}
// If any part of the segment is overlapping
// with the given range
int mid = (x + y) / 2;
return getSumUtil(x, mid, s, e, 2 * si + 1) +
getSumUtil(mid + 1, y, s, e, 2 * si + 2);
}
// Return sum of elements in range from index x (query
// start) to y (query end). It uses the getSumUtil() method
int getSum(int s, int x, int y)
{
// Checking for the absurd input values
if (x < 0 || y > s - 1 || x > y)
{
System.out.println("Input is Invalid");
return -1;
}
return getSumUtil(0, s - 1, x, y, 0);
}
// A recursive method that constructs the Segment Tree for
// a[x ... y]. si is the index of the current node in the segment
// tree. 
void constructSTUtil(int a[], int x, int y, int si)
{
// out of the range as x can never be greater than y
if (x > y)
{
return;
}
// when there is only one element in the array, keep that element in
// the current node of the segment tree and then return
if (x == y)
{
t[si] = a[x];
return;
}
// when there is more than single elements, then do the recursion
// for the left and the right subtrees and keep the sum
// of the values in the node
int m = (x + y) / 2;
constructSTUtil(a, x, m, 2 * si + 1);
constructSTUtil(a, m + 1, y, 2* si + 2);
t[si] = t[2 * si + 1] + t[2 * si + 2];
}
// method to build the segment tree from the array a[].
// The method allocates memory for the segment tree and
// invokes the constructSTUtil() method filling the memory allocated
void constructST(int a[], int s)
{
// filling the memory allocated for st
constructSTUtil(a, 0, s - 1, 0);
}
// main method
public static void main(String argvs[])
{
int a[] = {2, 4, 7, 10, 12, 13};
int s = a.length;
// Creating an object of the class LazySegTree
LazySegTree tObj = new LazySegTree();
// Building the segment tree from the array a[]
tObj.constructST(a, s);
// Displaying the sum of the values in the array a[] from the index 1 to 4
System.out.println("The sum of the values in the given range is: " +
tObj.getSum(s, 1, 4));
// Adding the sum 7 to all of the nodes sitting at the indices from 1 to 5.
tObj.updateRange(s, 1, 5, 7);
// Finding the sum after values are getting updated
System.out.println("The sum of the values, after updation, in the given range is: " +
tObj.getSum(s, 1, 4));
}
}

Output:

The sum of the values in the given range is: 33
The sum of the values, after updation, in the given range is: 61

Next TopicMagnanimous Number in Java

← prev next →

For Videos Join Our Youtube Channel: Join Now

Feedback

Send your Feedback to [email protected]

Help Others, Please Share

Learn Latest Tutorials

Splunk

SPSS

Swagger

Transact-SQL

Tumblr

ReactJS

Regex

Reinforcement Learning

R Programming

RxJS

React Native

Python Design Patterns

Python Pillow

Python Turtle

Keras

Preparation

Aptitude

Reasoning

Verbal Ability

Interview Questions

Company Questions

Trending Technologies

Artificial Intelligence

AWS

Selenium

Cloud Computing

Hadoop

ReactJS

Data Science

Angular 7

Blockchain

Git

Machine Learning

DevOps

B.Tech / MCA

DBMS

Data Structures

DAA

Operating System

Computer Network

Compiler Design

Computer Organization

Discrete Mathematics

Ethical Hacking

Computer Graphics

Software Engineering

Web Technology

Cyber Security

Automata

C Programming

C++

Java

.Net

Python

Programs

Control System

Data Mining

Data Warehouse

^{Like/Subscribe us for latest updates or newsletter}

Java Tutorial

Control Statements

Java Object Class

Java Inheritance

Java Polymorphism

Java Abstraction

Java Encapsulation

Java Array

Java OOPs Misc