Queries to find the minimum index in a range [L, R] having at least value X with updates

// Java program for the above approach
import java.util.ArrayList;
import java.util.List;

public class Main {

    // Function to find the minimum
    // index j in the range [L, R]
    // such that arr[j] >= X
    static int find(List<Integer> arr, int X, int L, int R) {
        for (int j = L; j <= R; j++) {
            if (arr.get(j) >= X) {
                return j;
            }
        }
        return -1;
    }

    // Function to update the array
    // element at Xth index to L
    static void update(List<Integer> arr, int X, int L) {
        arr.set(X, L);
    }

    // Driver Code
    public static void main(String[] args) {
        List<Integer> arr = new ArrayList<>();
        arr.add(1);
        arr.add(3);
        arr.add(2);
        arr.add(4);
        arr.add(6);

        List<List<Integer>> queries = new ArrayList<>();
        queries.add(List.of(2, 0, 4));
        queries.add(List.of(1, 2, 5));
        queries.add(List.of(4, 0, 4));
        queries.add(List.of(0, 0, 4));

        // Iterating on queries
        for (List<Integer> query : queries) {
            int x = query.get(0);
            int l = query.get(1);
            int r = query.get(2);

            if (x == 1) {
                // Function call for update
                update(arr, l, r);
            } else {
                // Function call for finding the minimum
                int j = find(arr, x, l, r);
                System.out.println(j);
            }
        }
    }
}

// Java program to implement 
// the above approach 
import java.util.*;

class GFG
{
 
static int maxN = 100;

// Stores nodes value of the Tree
static int Tree[] = new int[4 * maxN];

// Function to build segment tree
static void build(int arr[], int index,
           int s, int e)
{
    // Base Case
    if (s == e)
        Tree[index] = arr[s];

    else
    {
      
        // Find the value of mid
        int m = (s + e) / 2;

        // Update for left subtree
        build(arr, 2 * index, s, m);

        // Update for right subtree
        build(arr, 2 * index + 1,
              m + 1, e);

        // Update the value at the
        // current index
        Tree[index]
            = Math.max(Tree[2 * index],
                  Tree[2 * index + 1]);
    }
}

// Function for finding the index
// of the first element at least x
static int atleast_x(int index, int s, int e,
              int ql, int qr, int x)
{
    // If current range does
    // not lie in query range
    if (ql > e || qr < s)
        return -1;

    // If current range is inside
    // of query range
    if (s <= ql && e <= qr) {

        // Maximum value in this
        // range is less than x
        if (Tree[index] < x)
            return -1;

        // Finding index of first
        // value in this range
        while (s != e) {
            int m = (s + e) / 2;

            // Update the value of
            // the minimum index
            if (Tree[2 * index] >= x) {
                e = m;
                index = 2 * index;
            }
            else {
                s = m + 1;
                index = 2 * index + 1;
            }
        }
        return s;
    }

    // Find mid of the current range
    int m = (s + e) / 2;

    // Left subtree
    int val = atleast_x(2 * index, s,
                        m, ql, qr, x);
    if (val != -1)
        return val;

    // If it does not lie in
    // left subtree
    return atleast_x(2 * index + 1, m + 1,
                     e, ql, qr, x);
}

// Function for updating segment tree
static void update(int index, int s, int e,
            int new_val, int pos)
{
  
    // Update the value, we
    // reached leaf node
    if (s == e)
        Tree[index] = new_val;
    else 
    {

        // Find the mid
        int m = (s + e) / 2;

        if (pos <= m) 
        {

            // If pos lies in the
            // left subtree
            update(2 * index, s, m,
                   new_val, pos);
        }
        else
        {

            // pos lies in the
            // right subtree
            update(2 * index + 1,
                   m + 1, e,
                   new_val, pos);
        }

        // Update the maximum value
        // in the range
        Tree[index]
            = Math.max(Tree[2 * index],
                  Tree[2 * index + 1]);
    }
}

// Function to print the answer
// for the given queries
static void printAnswer(int[] arr, int n)
{
  
    // Build segment tree
    build(arr, 1, 0, n - 1);

    // Find index of first value
    // atleast 2 in range [0, n-1]
    System.out.println(atleast_x(1, 0, n - 1,
                      0, n - 1, 2));

    // Update value at index 2 to 5
    arr[2] = 5;
    update(1, 0, n - 1, 5, 2);

    // Find index of first value
    // atleast 4 in range [0, n-1]
    System.out.println(atleast_x(1, 0, n - 1,
                      0, n - 1, 4));

    // Find index of first value
    // atleast 0 in range [0, n-1]
    System.out.println(atleast_x(1, 0, n - 1,
                      0, n - 1, 0));
}
   
// Driver code
public static void main(String[] args)
{
    int arr[] = { 1, 3, 2, 4, 6 };
    int N = arr.length;

    // Function Call
    printAnswer(arr, N);
}
}

// This code is contributed by susmitakundugoaldanga.