Range_Min_Query_SEGMENT_TREE

// C++ program for range minimum 
// query using segment tree 
#include <bits/stdc++.h> 
using namespace std; 

// A utility function to get minimum of two numbers 
int minVal(int x, int y) { return (x < y)? x: y; } 

// A utility function to get the 
// middle index from corner indexes. 
int getMid(int s, int e) { return s + (e -s)/2; } 

/* A recursive function to get the 
minimum value in a given range 
of array indexes. The following 
are parameters for this function. 

	st --> Pointer to segment tree 
	index --> Index of current node in the 
		segment tree. Initially 0 is 
		passed as root is always at index 0 
	ss & se --> Starting and ending indexes 
				of the segment represented 
				by current node, i.e., st[index] 
	qs & qe --> Starting and ending indexes of query range */
int RMQUtil(int *st, int ss, int se, int qs, int qe, int index) 
{ 
	// If segment of this node is a part 
	// of given range, then return 
	// the min of the segment 
	if (qs <= ss && qe >= se) 
		return st[index]; 

	// If segment of this node 
	// is outside the given range 
	if (se < qs || ss > qe) 
		return INT_MAX; 

	// If a part of this segment 
	// overlaps with the given range 
	int mid = getMid(ss, se); 
	return minVal(RMQUtil(st, ss, mid, qs, qe, 2*index+1), 
				RMQUtil(st, mid+1, se, qs, qe, 2*index+2)); 
} 

// Return minimum of elements in range 
// from index qs (query start) to 
// qe (query end). It mainly uses RMQUtil() 
int RMQ(int *st, int n, int qs, int qe) 
{ 
	// Check for erroneous input values 
	if (qs < 0 || qe > n-1 || qs > qe) 
	{ 
		cout<<"Invalid Input"; 
		return -1; 
	} 

	return RMQUtil(st, 0, n-1, qs, qe, 0); 
} 

// A recursive function that constructs 
// Segment Tree for array[ss..se]. 
// si is index of current node in segment tree st 
int constructSTUtil(int arr[], int ss, int se, 
								int *st, int si) 
{ 
	// If there is one element in array, 
	// store it in current node of 
	// segment tree and return 
	if (ss == se) 
	{ 
		st[si] = arr[ss]; 
		return arr[ss]; 
	} 

	// If there are more than one elements, 
	// then recur for left and right subtrees 
	// and store the minimum of two values in this node 
	int mid = getMid(ss, se); 
	st[si] = minVal(constructSTUtil(arr, ss, mid, st, si*2+1), 
					constructSTUtil(arr, mid+1, se, st, si*2+2)); 
	return st[si]; 
} 

/* Function to construct segment tree 
from given array. This function allocates 
memory for segment tree and calls constructSTUtil() to 
fill the allocated memory */
int *constructST(int arr[], int n) 
{ 
	// Allocate memory for segment tree 

	//Height of segment tree 
	int x = (int)(ceil(log2(n))); 

	// Maximum size of segment tree 
	int max_size = 2*(int)pow(2, x) - 1; 

	int *st = new int[max_size]; 

	// Fill the allocated memory st 
	constructSTUtil(arr, 0, n-1, st, 0); 

	// Return the constructed segment tree 
	return st; 
} 

// Driver program to test above functions 
int main() 
{ 
	int arr[] = {1, 3, 2, 7, 9, 11}; 
	int n = sizeof(arr)/sizeof(arr[0]); 

	// Build segment tree from given array 
	int *st = constructST(arr, n); 

	int qs = 1; // Starting index of query range 
	int qe = 5; // Ending index of query range 

	// Print minimum value in arr[qs..qe] 
	cout<<"Minimum of values in range ["<<qs<<", "<<qe<<"] "<< 
	"is = "<<RMQ(st, n, qs, qe)<<endl; 

	return 0; 
} 

Updating the example from Youtube video:

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int getMid(int s, int e)
{
	return s + (e - s) / 2;
}

void updateValueUtil(vector<int> &st, int si, int L, int R, int i, int delta, int new_val)
{
	if (i < L || i > R)
		return;

	if (R == L)
	{
		st[si] += delta;
	}
	else
	{
		int mid = getMid(L, R);
		updateValueUtil(st, si * 2 + 1, L, mid, i, delta, new_val);
		updateValueUtil(st, si * 2 + 2, mid + 1, R, i, delta, new_val);
		st[si] = min(st[si * 2 + 1], st[si * 2 + 2]);
	}
}

void updateValue(vector<int> &arr, vector<int> &st, int n, int i, int new_val)
{
	if (i < 0 || i > n - 1)
	{
		cout << "Invalid input";
		return;
	}
	int delta = new_val - arr[i];
	arr[i] = new_val;
	updateValueUtil(st, 0, 0, n - 1, i, delta, new_val);
}

int getMinUtil(vector<int> &st, int L, int R, int sL, int sR, int si)
{
	if (sL <= L && sR >= R)
		return st[si];
	if (R < sL || L > sR)
		return INT_MAX;
	int mid = getMid(L, R);
	return min(getMinUtil(st, L, mid, sL, sR, 2 * si + 1),
		getMinUtil(st, mid + 1, R, sL, sR, 2 * si + 2));
}

int getMin(vector<int> &st, int n, int L, int R)
{
	if (L < 0 || R > n - 1 || L > R)
	{
		printf("Invalid Input");
		return -1;
	}
	return getMinUtil(st, 0, n - 1, L, R, 0);
}

int constructSTUtil(vector<int> &st, int si, vector<int> &arr, int L, int R)
{
	if (L == R)
	{
		st[si] = arr[L];
		return arr[L];
	}
	int mid = getMid(L, R);
	st[si] = min(constructSTUtil(st, si * 2 + 1, arr, L, mid),
		constructSTUtil(st, si * 2 + 2, arr, mid + 1, R));
	return st[si];
}

int getMaxSize(int n)
{
	int x = (int)(ceil(log2(n)));
	return 2 * (int)pow(2, x) - 1;
}

vector<int> constructST(vector<int> &arr)
{
	int max_size = getMaxSize(arr.size());
	vector<int> st(max_size, 0);
	constructSTUtil(st, 0, arr, 0, arr.size() - 1);
	return st;
}

void printSegmentTree(vector<int> st, int max_size)
{
	for (int i = 0; i < max_size; i++)
	{
		cout << st[i] << " ";
	}
	cout << endl;
}

int main()
{
	vector<int> arr{ 5, 2, 7, 1, 3 };
	vector<int> st = constructST(arr);
	printSegmentTree(st, getMaxSize(arr.size()));
	cout << "Min of values in given range = " << getMin(st, arr.size(), 2, 4) << endl;

	updateValue(arr, st, arr.size(), 3, 11);
	printSegmentTree(st, getMaxSize(arr.size()));
	cout << "Updated min of given range = " << getMin(st, arr.size(), 2, 4) << endl;

	updateValue(arr, st, arr.size(), 3, 1);
	printSegmentTree(st, getMaxSize(arr.size()));
	cout << "Updated min of given range = " << getMin(st, arr.size(), 2, 4) << endl;
	return 0;
}