Kth smallest element from an array of intervals

Given an array of intervals arr[] of size N, the task is to find the K^th smallest element among all the elements within the intervals of the given array.

Examples:

Input : arr[] = {{5, 11}, {10, 15}, {12, 20}}, K =12
Output: 13
Explanation: Elements in the given array of intervals are: {5, 6, 7, 8, 9, 10, 10, 11, 11, 12, 12, 13, 13, 14, 14, 15, 15, 16, 17, 18, 19, 20}.
Therefore, the K^th(=12^th) smallest element is 13.

Input: arr[] = {{5, 11}, {10, 15}, {12, 20}}, K = 7
Output:10

Naive Approach: The simplest approach is to generate a new array consisting of all the elements from the array of intervals. Sort the new array. Finally, return the K^th smallest element of the array.

Time Complexity: O(X*Log(X)), where X is the total number of elements in the intervals.
Auxiliary Space: O(X*log(X))

Efficient approach: To optimize the above approach, the idea is to use MinHeap. Follow the steps below to solve the problem.

1. Create a MinHeap, say pq to store all the intervals of the given array so that it returns the minimum element among all the elements of remaining intervals in O(1).
2. Pop the minimum interval from the MinHeap and check if the minimum element of the popped interval is less than the maximum element of the popped interval. If found to be true, then insert a new interval {minimum element of popped interval + 1, maximum element of the popped interval}.
3. Repeat the above step K – 1 times.
4. Finally, return the minimum element of the popped interval.

Below is the implementation of the above approach:

C++14

// C++ Program to implement
// the above approach

#include <bits/stdc++.h>
using namespace std;

// Function to get the Kth smallest
// element from an array of intervals
int KthSmallestNum(pair<int, int> arr[],
                   int n, int k)
{

    // Store all the intervals so that it
    // returns the minimum element in O(1)
    priority_queue<pair<int, int>,
                   vector<pair<int, int> >,
                   greater<pair<int, int> > >
        pq;

    // Insert all Intervals into the MinHeap
    for (int i = 0; i < n; i++) {
        pq.push({ arr[i].first,
                  arr[i].second });
    }

    // Stores the count of
    // popped elements
    int cnt = 1;

    // Iterate over MinHeap
    while (cnt < k) {

        // Stores minimum element
        // from all remaining intervals
        pair<int, int> interval
            = pq.top();

        // Remove minimum element
        pq.pop();

        // Check if the minimum of the current
        // interval is less than the maximum
        // of the current interval
        if (interval.first < interval.second) {

            // Insert new interval
            pq.push(
                { interval.first + 1,
                  interval.second });
        }

        cnt++;
    }
    return pq.top().first;
}

// Driver Code
int main()
{
    // Intervals given
    pair<int, int> arr[]
        = { { 5, 11 },
            { 10, 15 },
            { 12, 20 } };

    // Size of the arr
    int n = sizeof(arr) / sizeof(arr[0]);

    int k = 12;

    cout << KthSmallestNum(arr, n, k);
}

Java

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

class GFG{

// Function to get the Kth smallest
// element from an array of intervals
public static int KthSmallestNum(int arr[][], int n,
                                 int k)
{

    // Store all the intervals so that it
    // returns the minimum element in O(1)
    PriorityQueue<int[]> pq = new PriorityQueue<>(
                              (a, b) -> a[0] - b[0]);

    // Insert all Intervals into the MinHeap
    for(int i = 0; i < n; i++)
    {
        pq.add(new int[]{arr[i][0],
                         arr[i][1]});
    }

    // Stores the count of
    // popped elements
    int cnt = 1;

    // Iterate over MinHeap
    while (cnt < k)
    {

        // Stores minimum element
        // from all remaining intervals
        int[] interval = pq.poll();

        // Check if the minimum of the current
        // interval is less than the maximum
        // of the current interval
        if (interval[0] < interval[1])
        {

            // Insert new interval
            pq.add(new int[]{interval[0] + 1,
                             interval[1]});
        }
        cnt++;
    }
    return pq.peek()[0];
}

// Driver Code
public static void main(String args[])
{

    // Intervals given
    int arr[][] = { { 5, 11 },
                    { 10, 15 },
                    { 12, 20 } };

    // Size of the arr
    int n = arr.length;

    int k = 12;

    System.out.println(KthSmallestNum(arr, n, k));
}
}

// This code is contributed by hemanth gadarla

Python3

# Python3 program to implement
# the above approach

# Function to get the Kth smallest
# element from an array of intervals
def KthSmallestNum(arr, n, k):

    # Store all the intervals so that it
    # returns the minimum element in O(1)
    pq = []

    # Insert all Intervals into the MinHeap
    for i in range(n):
        pq.append([arr[i][0], arr[i][1]])

    # Stores the count of
    # popped elements
    cnt = 1

    # Iterate over MinHeap
    while (cnt < k):

        # Stores minimum element
        # from all remaining intervals
        pq.sort(reverse = True)
        interval = pq[0]

        # Remove minimum element
        pq.remove(pq[0])

        # Check if the minimum of the current
        # interval is less than the maximum
        # of the current interval
        if (interval[0] < interval[1]):

            # Insert new interval
            pq.append([interval[0] + 1,
                       interval[1]])

        cnt += 1

    pq.sort(reverse = True)
    return pq[0][0] + 1

# Driver Code
if __name__ == '__main__':

    # Intervals given
    arr = [ [ 5, 11 ],
            [ 10, 15 ],
            [ 12, 20 ] ]

    # Size of the arr
    n = len(arr)

    k = 12

    print(KthSmallestNum(arr, n, k))

# This code is contributed by SURENDRA_GANGWAR

C#

// C# Program to implement
// the above approach
using System;
using System.Collections;
using System.Collections.Generic;
class GFG {

    // Function to get the Kth smallest
    // element from an array of intervals
    static int KthSmallestNum(int[,] arr, int n, int k)
    {
        // Store all the intervals so that it
        // returns the minimum element in O(1)
        ArrayList pq = new ArrayList();

        // Insert all Intervals into the MinHeap
        for(int i = 0; i < n; i++)
        {
            pq.Add(new Tuple<int,int>(arr[i,0], arr[i,1]));
        }

        // Stores the count of
        // popped elements
        int cnt = 1;

        // Iterate over MinHeap
        while (cnt < k)
        {
            // Stores minimum element
            // from all remaining intervals
            pq.Sort();
            pq.Reverse();
            Tuple<int,int> interval = (Tuple<int,int>)pq[0];

            // Remove minimum element
            pq.RemoveAt(0);

            // Check if the minimum of the current
            // interval is less than the maximum
            // of the current interval
            if (interval.Item1 < interval.Item2)
            {
                // Insert new interval
                pq.Add(new Tuple<int,int>(interval.Item1 + 1, interval.Item2));
            }
            cnt += 1;
        }
        pq.Sort();
        pq.Reverse();
        return ((Tuple<int,int>)pq[0]).Item1 + 1;
    }

  // Driver code
  static void Main()
  {

    // Intervals given
    int[,] arr = { { 5, 11 },
            { 10, 15 },
            { 12, 20 } };

    // Size of the arr
    int n = arr.GetLength(0);
    int k = 12;
    Console.WriteLine(KthSmallestNum(arr, n, k));
  }
}

// This code is contributed by divyeshrabadiya07

Javascript

<script>

// JavaScript Program to implement
// the above approach

// Function to get the Kth smallest
// element from an array of intervals
function KthSmallestNum(arr, n, k)
{
    // Store all the intervals so that it
    // returns the minimum element in O(1)
    var pq = [];

    // Insert all Intervals into the MinHeap
    for(var i = 0; i < n; i++)
    {
        pq.push([arr[i][0], arr[i][1]]);
    }

    // Stores the count of
    // popped elements
    var cnt = 1;

    // Iterate over MinHeap
    while (cnt < k)
    {
        // Stores minimum element
        // from all remaining intervals
        pq.sort((a,b)=>{
        if(a[0]==b[0])
            return a[1]-b[1]
        return a[0]-b[0]
        });
        var interval = pq[0];

        // Remove minimum element
        pq.shift();

        // Check if the minimum of the current
        // interval is less than the maximum
        // of the current interval
        if (interval[0] < interval[1])
        {
            // Insert new interval
            pq.push([interval[0] + 1, interval[1]]);
        }
        cnt += 1;
    }
    pq.sort((a,b) =>
    {
        if(a[0]==b[0])
            return a[1]-b[1]
        return a[0]-b[0]
    });
    return (pq[0])[0];
}

 // Driver code
// Intervals given
var arr = [ [ 5, 11 ],
        [ 10, 15 ],
        [ 12, 20 ] ];

// Size of the arr
var n = arr.length;
var k = 12;
document.write(KthSmallestNum(arr, n, k));

</script>

Output:

13

Time Complexity: O(K*logK)
Auxiliary Space: O(N)