Reconstructing Segment Tree
Last Updated :
09 Mar, 2023
We are given 2*N - 1 integers. We need to check whether it is possible to construct a Range Minimum Query segment tree for an array of N distinct integers from these integers. If so, we must output the segment tree array. N is given to be a power of 2.
An RMQ segment tree is a binary tree where each node is equal to the minimum value of its children. This type of tree is used to efficiently find the minimum value of elements in a given range.
Input : 1 1 1 1 2 2 3 3 3 4 4 5 6 7 8
Output : 1 1 3 1 2 3 4 1 5 2 6 3 7 4 8
The segment tree is shown below
Input : -381 -460 -381 95 -460 855 -242
405 -460 982 -381 -460 95 981 855
Output : -460 -460 -381 -460 95 -381 855
-460 -242 95 405 -381 981 855 982
By constructing a segment tree from the output,
we can see that it a valid tree for RMQ and the
leaves are all distinct integers.
What we first do is iterate through the given integers counting the number of occurrences of each number, then sorting them by value. In C++, we can use the data structure map, which stores elements in sorted order.
Now we maintain a queue for each possible level of the segment tree. We put the initial root of the tree (array index 0) into the queue for the max level. We then insert the smallest element into the leftmost nodes. We then detach these nodes from the main tree. As we detach a node, we create a new tree of height h - 1, where h is the height of the current node. We can see this in figure 2. We insert the root node of this new tree into the appropriate queue based on its height.
We go through each element, getting a tree of the appropriate height based on the number of occurrences of that element. If at any point such a tree does not exist, then it is not possible to create a segment tree.
CPP
// C++ Program to Create RMQ Segment Tree
#include <bits/stdc++.h>
using namespace std;
// Returns true if it is possible to construct
// a range minimum segment tree from given array.
bool createTree(int arr[], int N)
{
// Store the height of the final tree
const int height = log2(N) + 1;
// Container to sort and store occurrences of elements
map<int, int> multi;
// Insert elements into the container
for (int i = 0; i < 2 * N - 1; ++i)
++multi[arr[i]];
// Used to store new subtrees created
set<int> Q[height];
// Insert root into set
Q[height - 1].emplace(0);
// Iterate through each unique element in set
for (map<int, int>::iterator it = multi.begin();
it != multi.end(); ++it)
{
// Number of occurrences is greater than height
// Or, no subtree exists that can accommodate it
if (it->second > height || Q[it->second - 1].empty())
return false;
// Get the appropriate subtree
int node = *Q[it->second - 1].begin();
// Delete the subtree we grabbed
Q[it->second - 1].erase(Q[it->second - 1].begin());
int level = 1;
for (int i = node; i < 2 * N - 1;
i = 2 * i + 1, ++level)
{
// Insert new subtree created into root
if (2 * i + 2 < 2 * N - 1)
Q[it->second - level - 1].emplace(2 * i + 2);
// Insert element into array at position
arr[i] = it->first;
}
}
return true;
}
// Driver program
int main()
{
int N = 8;
int arr[2 * N - 1] = {1, 1, 1, 1, 2, 2,
3, 3, 3, 4, 4, 5, 6, 7, 8};
if (createTree(arr, N))
{
cout << "YES\n";
for (int i = 0; i < 2 * N - 1; ++i)
cout << arr[i] << " ";
}
else
cout << "NO\n";
return 0;
}
import java.util.*;
public class RMQSegmentTree {
// Returns true if it is possible to construct
// a range minimum segment tree from given array.
public static boolean createTree(int[] arr, int N)
{
// Store the height of the final tree
final int height
= (int)(Math.log(N) / Math.log(2)) + 1;
// Container to sort and store occurrences of
// elements
Map<Integer, Integer> multi = new HashMap<>();
// Insert elements into the container
for (int i = 0; i < 2 * N - 1; ++i)
multi.put(arr[i],
multi.getOrDefault(arr[i], 0) + 1);
// Used to store new subtrees created
Set<Integer>[] Q = new HashSet[height];
for (int i = 0; i < height; i++) {
Q[i] = new HashSet<Integer>();
}
// Insert root into set
Q[height - 1].add(0);
// Iterate through each unique element in set
for (Map.Entry<Integer, Integer> entry :
multi.entrySet()) {
int key = entry.getKey();
int value = entry.getValue();
// Number of occurrences is greater than height
// Or, no subtree exists that can accommodate it
if (value > height || Q[value - 1].isEmpty())
return false;
// Get the appropriate subtree
int node = Q[value - 1].iterator().next();
// Delete the subtree we grabbed
Q[value - 1].remove(node);
int level = 1;
for (int i = node; i < 2 * N - 1;
i = 2 * i + 1, ++level) {
// Insert new subtree created into root
if (2 * i + 2 < 2 * N - 1)
Q[value - level - 1].add(2 * i + 2);
// Insert element into array at position
arr[i] = key;
}
}
return true;
}
// Driver program
public static void main(String[] args)
{
int N = 8;
int[] arr = { 1, 1, 1, 1, 2, 2, 3, 3,
3, 4, 4, 5, 6, 7, 8 };
if (createTree(arr, N)) {
System.out.println("YES");
for (int i = 0; i < 2 * N - 1; ++i)
System.out.print(arr[i] + " ");
}
else {
System.out.println("NO");
}
}
}
# Python Program to Create RMQ Segment Tree
from typing import List
from math import log2
# Returns true if it is possible to construct
# a range minimum segment tree from given array.
def createTree(arr: List[int], N: int) -> bool:
# Store the height of the final tree
height = int(log2(N)) + 1
# Container to sort and store occurrences of elements
multi = {}
# Insert elements into the container
for i in range(2 * N - 1):
if arr[i] not in multi:
multi[arr[i]] = 0
multi[arr[i]] += 1
# Used to store new subtrees created
Q = [set() for _ in range(height)]
# Insert root into set
Q[height - 1].add(0)
# Iterate through each unique element in set
for k, v in multi.items():
# Number of occurrences is greater than height
# Or, no subtree exists that can accommodate it
if (v > height or len(Q[v - 1]) == 0):
return False
# Get the appropriate subtree
node = sorted(Q[v - 1])[0]
# Delete the subtree we grabbed
Q[v - 1].remove(sorted(Q[v - 1])[0])
level = 1
# for (int i = node; i < 2 * N - 1;
# i = 2 * i + 1, ++level)
i = node
while i < 2 * N - 1:
# Insert new subtree created into root
if (2 * i + 2 < 2 * N - 1):
Q[v - level - 1].add(2 * i + 2)
# Insert element into array at position
arr[i] = k
level += 1
i = 2 * i + 1
return True
# Driver program
if __name__ == "__main__":
N = 8
arr = [1, 1, 1, 1, 2, 2, 3, 3, 3, 4, 4, 5, 6, 7, 8]
if (createTree(arr, N)):
print("YES")
# for (int i = 0; i < 2 * N - 1; ++i)
for i in range(2 * N - 1):
print(arr[i], end=" ")
else:
print("No")
# This code is contributed by sanjeev2552
// C# Program to Create RMQ Segment Tree
using System;
using System.Collections.Generic;
public class RMQSegmentTree {
// Returns true if it is possible to construct
// a range minimum segment tree from given array.
static bool CreateTree(int[] arr, int N)
{
// Store the height of the final tree
int height = (int)(Math.Log(N) / Math.Log(2)) + 1;
// Container to sort and store occurrences of
// elements
Dictionary<int, int> multi
= new Dictionary<int, int>();
// Insert elements into the container
for (int i = 0; i < 2 * N - 1; ++i)
if (multi.ContainsKey(arr[i]))
multi[arr[i]]++;
else
multi[arr[i]] = 1;
// Used to store new subtrees created
SortedSet<int>[] Q = new SortedSet<int>[ height ];
// Initialize each set in the array
for (int i = 0; i < height; i++)
Q[i] = new SortedSet<int>();
// Insert root into set
Q[height - 1].Add(0);
// Iterate through each unique element in set
foreach(KeyValuePair<int, int> entry in multi)
{
int count = entry.Value;
int key = entry.Key;
// Number of occurrences is greater than height
// Or, no subtree exists that can accommodate it
if (count > height || Q[count - 1].Count == 0)
return false;
// Get the appropriate subtree
int node = Q[count - 1].Min;
// Delete the subtree we grabbed
Q[count - 1].Remove(node);
int level = 1;
for (int i = node; i < 2 * N - 1;
i = 2 * i + 1, ++level) {
// Insert new subtree created into root
if (2 * i + 2 < 2 * N - 1)
Q[count - level - 1].Add(2 * i + 2);
// Insert element into array at position
arr[i] = key;
}
}
return true;
}
// Driver program
static public void Main()
{
int N = 8;
int[] arr = { 1, 1, 1, 1, 2, 2, 3, 3,
3, 4, 4, 5, 6, 7, 8 };
if (CreateTree(arr, N)) {
Console.WriteLine("YES");
for (int i = 0; i < 2 * N - 1; ++i)
Console.Write(arr[i] + " ");
}
else
Console.WriteLine("NO");
Console.ReadLine();
}
}
// This code is contributed by prasad264
// JavaScript Program to Create RMQ Segment Tree
// Returns true if it is possible to construct
// a range minimum segment tree from given array.
function createTree(arr, N) {
// Store the height of the final tree
const height = Math.floor(Math.log2(N)) + 1;
// Container to sort and store occurrences of elements
const multi = {};
// Insert elements into the container
for (let i = 0; i < 2 * N - 1; i++) {
if (multi[arr[i]] == undefined) {
multi[arr[i]] = 0;
}
multi[arr[i]] += 1;
}
// Used to store new subtrees created
const Q = new Array(height);
for (let i = 0; i < height; i++) {
Q[i] = new Set();
}
// Insert root into set
Q[height - 1].add(0);
// Iterate through each unique element in set
for (const [k, v] of Object.entries(multi)) {// Number of occurrences is greater than height
// Or, no subtree exists that can accommodate it
if (v > height || Q[v - 1].size == 0) {
return false;
}
// Get the appropriate subtree
const node = Math.min(...Q[v - 1]);
// Delete the subtree we grabbed
Q[v - 1].delete(node);
let level = 1;
let i = node;
while (i < 2 * N - 1) {
// Insert new subtree created into root
if (2 * i + 2 < 2 * N - 1) {
Q[v - level - 1].add(2 * i + 2);
}
// Insert element into array at position
arr[i] = k;
level += 1;
i = 2 * i + 1;
}
}
return true;
}
// Driver program
const N = 8;
const arr = [1, 1, 1, 1, 2, 2, 3, 3, 3, 4, 4, 5, 6, 7, 8];
if (createTree(arr, N)) {
console.log("YES");
let ans="";
for (let i = 0; i < 2 * N - 1; i++) {
ans = ans + arr[i] + " ";
}
console.log(ans);
} else {
console.log("No");
}
Output:
YES
1 1 3 1 2 3 4 1 5 2 6 3 7 4 8
Main time complexity is caused by sorting elements.
Time Complexity: O(N log N)
Space Complexity: O(N)
Related Topic: Segment Tree
Similar Reads
Segment Tree Segment Tree is a data structure that allows efficient querying and updating of intervals or segments of an array. It is particularly useful for problems involving range queries, such as finding the sum, minimum, maximum, or any other operation over a specific range of elements in an array. The tree
3 min read
Segment tree meaning in DSA A segment tree is a data structure used to effectively query and update ranges of array members. It's typically implemented as a binary tree, with each node representing a segment or range of array elements. Segment tree Characteristics of Segment Tree:A segment tree is a binary tree with a leaf nod
2 min read
Introduction to Segment Trees - Data Structure and Algorithm Tutorials A Segment Tree is used to store information about array intervals in its nodes.It allows efficient range queries over array intervals.Along with queries, it allows efficient updates of array items.For example, we can perform a range summation of an array between the range L to R in O(Log n) while al
15+ min read
Persistent Segment Tree | Set 1 (Introduction) Prerequisite : Segment Tree Persistency in Data Structure Segment Tree is itself a great data structure that comes into play in many cases. In this post we will introduce the concept of Persistency in this data structure. Persistency, simply means to retain the changes. But obviously, retaining the
15+ min read
Segment tree | Efficient implementation Let us consider the following problem to understand Segment Trees without recursion.We have an array arr[0 . . . n-1]. We should be able to, Find the sum of elements from index l to r where 0 <= l <= r <= n-1Change the value of a specified element of the array to a new value x. We need to d
12 min read
Iterative Segment Tree (Range Maximum Query with Node Update) Given an array arr[0 . . . n-1]. The task is to perform the following operation: Find the maximum of elements from index l to r where 0 <= l <= r <= n-1.Change value of a specified element of the array to a new value x. Given i and x, change A[i] to x, 0 <= i <= n-1. Examples: Input:
14 min read
Range Sum and Update in Array : Segment Tree using Stack Given an array arr[] of N integers. The task is to do the following operations: Add a value X to all the element from index A to B where 0 ? A ? B ? N-1.Find the sum of the element from index L to R where 0 ? L ? R ? N-1 before and after the update given to the array above.Example: Input: arr[] = {1
15+ min read
Dynamic Segment Trees : Online Queries for Range Sum with Point Updates Prerequisites: Segment TreeGiven a number N which represents the size of the array initialized to 0 and Q queries to process where there are two types of queries: 1 P V: Put the value V at position P.2 L R: Output the sum of values from L to R. The task is to answer these queries. Constraints: 1 ? N
15+ min read
Applications, Advantages and Disadvantages of Segment Tree First, let us understand why we need it prior to landing on the introduction so as to get why this concept was introduced. Suppose we are given an array and we need to find out the subarray Purpose of Segment Trees: A segment tree is a data structure that deals with a range of queries over an array.
4 min read
Lazy Propagation
Lazy Propagation in Segment TreeSegment tree is introduced in previous post with an example of range sum problem. We have used the same "Sum of given Range" problem to explain Lazy propagation  How does update work in Simple Segment Tree? In the previous post, update function was called to update only a single value in array. Ple
15+ min read
Lazy Propagation in Segment Tree | Set 2Given an array arr[] of size N. There are two types of operations: Update(l, r, x) : Increment the a[i] (l <= i <= r) with value x.Query(l, r) : Find the maximum value in the array in a range l to r (both are included).Examples: Input: arr[] = {1, 2, 3, 4, 5} Update(0, 3, 4) Query(1, 4) Output
15+ min read
Flipping Sign Problem | Lazy Propagation Segment TreeGiven an array of size N. There can be multiple queries of the following types. update(l, r) : On update, flip( multiply a[i] by -1) the value of a[i] where l <= i <= r . In simple terms, change the sign of a[i] for the given range.query(l, r): On query, print the sum of the array in given ran
15+ min read