Queries for k-th smallest in given ranges

import java.util.*;

class GFG
{

// Structure to store the
// start and end point
static class Interval
{
    int s;
    int e;
    Interval(int a,int b)
    {
        s = a;
        e = b;
    }
};
static class Sortby implements Comparator<Interval> 
{ 
    // Comparison function for sorting
    public int compare(Interval a, Interval b)
    {
        return a.s - b.s;
    }
} 

// Function to find Kth smallest number in a Vector
// of merged intervals
static int kthSmallestNum(Vector<Interval> merged, int k)
{
    int n = merged.size();

    // Traverse merged.get( )o find
    // Kth smallest element using Linear search.
    for (int j = 0; j < n; j++)
    {
        if (k <= Math.abs(merged.get(j).e -
                    merged.get(j).s + 1))
            return (merged.get(j).s + k - 1);

        k = k - Math.abs(merged.get(j).e -
                    merged.get(j).s + 1);
    }

    if (k != 0)
        return -1;
    return 0;
}

// To combined both type of ranges,
// overlapping as well as non-overlapping.
static Vector<Interval> mergeIntervals(Vector<Interval> merged,
                Interval arr[], int n)
{
    // Sorting intervals according to start
    // time
    Arrays.sort(arr, new Sortby());

    // Merging all intervals into merged
    merged.add(arr[0]);
    for (int i = 1; i < n; i++)
    {
        // To check if starting point of next
        // range is lying between the previous
        // range and ending point of next range
        // is greater than the Ending point
        // of previous range then update ending
        // point of previous range by ending
        // point of next range.
        Interval prev = merged.get(merged.size() - 1);
        Interval curr = arr[i];
        if ((curr.s >= prev.s &&
            curr.s <= prev.e) &&
            (curr.e > prev.e))

            merged.get(merged.size()-1).e = curr.e;

        else
        {
            // If starting point of next range
            // is greater than the ending point
            // of previous range then store next range
            // in merged.get(.)         if (curr.s > prev.e)
                merged.add(curr);
        }
    }
    return merged;
}

public static void main(String args[])
{
    Interval arr[] = {new Interval(2, 6), new Interval(4, 7)};
    int n = arr.length;
    int query[] = {5, 8};
    int q = query.length;

    // Merge all intervals into merged.get()) 
    Vector<Interval> merged = new Vector<Interval>();
    merged=mergeIntervals(merged, arr, n);

    // Processing all queries on merged
    // intervals
    for (int i = 0; i < q; i++)
        System.out.println( kthSmallestNum(merged, query[i]));
}
}

import java.util.*;

public class Main {

    public static List<Integer>
    kthSmallestNum(List<List<Integer> > range,
                   List<Integer> queries)
    {
        // sort the ranges
        Collections.sort(
            range, Comparator.comparingInt(a -> a.get(0)));

        // merge the overlapping intervals
        List<List<Integer> > merged = mergeIntervals(range);

        // set to store the cumulative sum of number of
        // elements in each range
        // eg {1 4} {6 8} {9 10} would store {4 7 9} in set.
        NavigableSet<Integer> s = new TreeSet<>();
        int cumsum = 0;
        for (List<Integer> cur_range : merged) {
            int num_ele
                = cur_range.get(1) - cur_range.get(0) + 1;
            cumsum += num_ele;
            s.add(cumsum);
        }

        // final vector to store the result of each query
        List<Integer> fin = new ArrayList<>();

        // for each query get the lower bound of required
        // kth smallest element.
        // go to the index returned by lower_bound and get
        // the required element
        for (int q : queries) {
            Integer tail = s.ceiling(q);
            if (tail == null) {
                fin.add(-1);

                // if the required element is in ith range.
                // then discard previous range elements
                // if previous elements are prevele. then
                // look for k=q-prevele in the current range
            }
            else {
                int idx = s.headSet(tail, true).size() - 1;
                int prevele
                    = idx == 0
                          ? 0
                          : s.headSet(tail, false).last();
                int kth = q - prevele;
                fin.add(merged.get(idx).get(0) + kth - 1);
            }
        }
        return fin;
    }

    private static List<List<Integer> >
    mergeIntervals(List<List<Integer> > range)
    {
        int n = range.size();
        List<List<Integer> > fin = new ArrayList<>();
        for (int i = 0; i < n - 1; i++) {
            if (range.get(i).get(1)
                >= range.get(i + 1).get(0)) {
                range.get(i + 1).set(
                    0, Math.min(range.get(i).get(0),
                                range.get(i + 1).get(0)));
                range.get(i + 1).set(
                    1, Math.max(range.get(i).get(1),
                                range.get(i + 1).get(1)));
            }
            else {
                fin.add(range.get(i));
            }
        }
        fin.add(range.get(n - 1));
        return fin;
    }

    public static void main(String[] args)
    {
        List<List<Integer> > range = Arrays.asList(
            Arrays.asList(1, 4), Arrays.asList(6, 8));
        List<Integer> queries = Arrays.asList(2, 6, 10);
        List<Integer> ans = kthSmallestNum(range, queries);
        for (int it : ans) {
            System.out.print(it + " ");
        }
    }
}