Queries to find the first array element exceeding K with updates

// C# program to implement
// the above approach
using System;

class GFG{

// Function to find the mid
// of start and end
static int getMid(int s, int e)
{
    return s + (e - s) / 2;
}

static void updateValue(int[] arr, int[] st, int ss,
                        int se, int index, int value,
                        int node)
{
    
    // If index is out of range
    if (index < ss || index > se) 
    {
        Console.WriteLine("Invalid Input");
        return;
    }

    // If a leaf node is found
    if (ss == se)
    {
        
        // Update value in array
        arr[index] = value;

        // Update value in
        // the segment tree
        st[node] = value;
    }
    else 
    {
        
        // Stores mid of ss and se
        int mid = getMid(ss, se);

        // If index is less than or
        // equal to mid
        if (index >= ss && index <= mid) 
        {
            
            // Recursively call for left subtree
            updateValue(arr, st, ss, mid, index, value,
                        2 * node + 1);
        }
        else 
        {
            
            // Recursively call for right subtree
            updateValue(arr, st, mid + 1, se, index,
                        value, 2 * node + 2);
        }

        // Update st[node]
        st[node] = Math.Max(st[2 * node + 1],
                            st[2 * node + 2]);
    }
}

// Function to find the position of first element
// which is greater than or equal to X
static int findMinimumIndex(int[] st, int ss, int se,
                            int K, int si)
{
    
    // If no such element found in current
    // subtree which is greater than or
    // equal to K
    if (st[si] < K)
        return 1000000000;

    // If current node is leaf node
    if (ss == se)
    {
        
        // If value of current node
        // is greater than or equal to X
        if (st[si] >= K) 
        {
            return ss;
        }
        return 1000000000;
    }

    // Stores mid of ss and se
    int mid = getMid(ss, se);

    int l = 1000000000;

    // If root of left subtree is
    // greater than or equal to K
    if (st[2 * si + 1] >= K)
        l = Math.Min(l, findMinimumIndex(st, ss, mid, K,
                                         2 * si + 1));

    // If no such array element is
    // found in the left subtree
    if (l == 1e9 && st[2 * si + 2] >= K)
        l = Math.Min(l,
                     findMinimumIndex(st, mid + 1, se,
                                    K, 2 * si + 2));

    return l;
}

// Function to build a segment tree
static int Build(int[] arr, int ss, int se,
                 int[] st, int si)
{
    
    // If current node is leaf node
    if (ss == se) 
    {
        st[si] = arr[ss];
        return arr[ss];
    }

    // Store mid of ss and se
    int mid = getMid(ss, se);

    // Stores maximum of left subtree and rightsubtree
    st[si] = Math.Max(
        Build(arr, ss, mid, st, si * 2 + 1),
        Build(arr, mid + 1, se, st, si * 2 + 2));

    return st[si];
}

// Function to initialize a segment tree
// for the given array
static int[] constructST(int[] arr, int n)
{
    
    // Height of segment tree
    int x = (int)Math.Ceiling(Math.Log(n) /
                              Math.Log(2));

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

    // Allocate memory
    int[] st = new int[max_size];

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

    // Return the constructed segment tree
    return st;
}

static void PerformQueries(int[] arr, int N, int[][] Q)
{
    
    // Build segment tree for the given array
    int[] st = constructST(arr, N);

    // Traverse the query array
    for(int i = 0; i < Q.Length; i++) 
    {
        
        // If query of type 1 found
        if (Q[i][0] == 1)
            updateValue(arr, st, 0, N - 1, 
                        Q[i][1] - 1, 5, 0);
        else 
        {
            
            // Stores index of first array element
            // which is greater than or equal
            // to Q[i][1]
            int f = findMinimumIndex(st, 0, N - 1,
                                     Q[i][1], 0);
            if (f < N)
                Console.Write(f + 1 + " ");
            else
                Console.Write(-1 + " ");
        }
    }
}

// Driver Code
public static void Main(string[] args)
{
    int[] arr = { 1, 3, 2, 4, 6 };
    int[][] Q = new int[4][];

    // Initialize the elements
    Q[0] = new int[] { 2, 5 };
    Q[1] = new int[] { 1, 3, 5 };
    Q[2] = new int[] { 2, 4 };
    Q[3] = new int[] { 2, 8 };

    int N = arr.Length;
    PerformQueries(arr, N, Q);
}
}

// This code is contributed by ukasp