Skip to content
Related Articles

Related Articles

Improve Article
Save Article
Like Article

Find least non-overlapping number from a given set of intervals

  • Difficulty Level : Medium
  • Last Updated : 03 Aug, 2021

Given an array interval of pairs of integers representing the starting and ending points of the interval of size N. The task is to find the smallest non-negative integer which is a non-overlapping number from the given set of intervals. 

Input constraints: 

1 \le N \le 10^{5}0 \le interval[i] \le 10^{9}

Examples: 

Input: interval = {{0, 4}, {6, 8}, {2, 3}, {9, 18}} 
Output:
Explanation: 
The smallest non-negative integer which is non-overlapping to all set of the intervals is 5.

Input: interval = {{0, 14}, {86, 108}, {22, 30}, {5, 17}} 
Output: 18  

Naive Approach:  

  • Create a visited array of size MAX, and for every interval mark all value true from start to end.
  • Finally, iterate from 1 to MAX and find the smallest value which is not visited.

However, this approach will not work if the interval coordinates are up to 10 9

Time Complexity: O (N 2) 
Auxiliary Space: O (MAX)

Efficient Approach: 

  1. Instead of iterating from start to end just create a visited array and for each range, mark vis[start] = 1 and vis[end+1] = -1.
  2. Take the prefix sum of the array.
  3. Then iterate over the array to find the first integer with value 0.

Here is the implementation of the above approach: 

C++




// C++ program to find the
// least non-overlapping number
// from a given set intervals
 
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e5 + 5;
 
// function to find the smallest
// non-overlapping number
void find_missing(
    vector<pair<int, int> > interval)
{
    // create a visited array
    vector<int> vis(MAX);
 
    for (int i = 0; i < interval.size(); ++i) {
        int start = interval[i].first;
        int end = interval[i].second;
        vis[start]++;
        vis[end + 1]--;
    }
 
    // find the first missing value
    for (int i = 1; i < MAX; i++) {
        vis[i] += vis[i - 1];
        if (!vis[i]) {
            cout << i << endl;
            return;
        }
    }
}
// Driver function
int main()
{
 
    vector<pair<int, int> > interval
        = { { 0, 14 }, { 86, 108 },
            { 22, 30 }, { 5, 17 } };
    find_missing(interval);
    return 0;
}

Java




// Java program to find the
// least non-overlapping number
// from a given set intervals
class GFG{
   
static int MAX = (int) (1e5 + 5);
static class pair
{
    int first, second;
    public pair(int first, int second) 
    {
        this.first = first;
        this.second = second;
    }   
}
// function to find the smallest
// non-overlapping number
static void find_missing(
    pair[] interval)
{
    // create a visited array
    int [] vis = new int[MAX];
 
    for (int i = 0; i < interval.length; ++i)
    {
        int start = interval[i].first;
        int end = interval[i].second;
        vis[start]++;
        vis[end + 1]--;
    }
 
    // find the first missing value
    for (int i = 1; i < MAX; i++) {
        vis[i] += vis[i - 1];
        if (vis[i]==0) {
            System.out.print(i +"\n");
            return;
        }
    }
}
// Driver function
public static void main(String[] args)
{
 
    pair []interval = {new pair( 0, 14 ),
                       new pair( 86, 108 ),
                       new pair( 22, 30 ),
                       new pair( 5, 17 )};
    find_missing(interval);
}
}
 
// This code is contributed by Rohit_ranjan

Python3




# Python3 program to find the
# least non-overlapping number
# from a given set intervals
MAX = int(1e5 + 5)
 
# Function to find the smallest
# non-overlapping number
def find_missing(interval):
     
    # Create a visited array
    vis = [0] * (MAX)
 
    for i in range(len(interval)):
        start = interval[i][0]
        end = interval[i][1]
        vis[start] += 1
        vis[end + 1] -= 1
 
    # Find the first missing value
    for i in range(1, MAX):
        vis[i] += vis[i - 1]
         
        if (vis[i] == 0):
            print(i)
            return
 
# Driver code
interval = [ [ 0, 14 ], [ 86, 108 ],
             [ 22, 30 ], [ 5, 17 ] ]
              
find_missing(interval)
 
# This code is contributed by divyeshrabadiya07

C#




// C# program to find the
// least non-overlapping number
// from a given set intervals
using System;
 
class GFG{
 
static int MAX = (int)(1e5 + 5);
class pair
{
    public int first, second;
    public pair(int first, int second)
    {
        this.first = first;
        this.second = second;
    }
}
 
// Function to find the smallest
// non-overlapping number
static void find_missing(pair[] interval)
{
     
    // Create a visited array
    int [] vis = new int[MAX];
 
    for(int i = 0; i < interval.Length; ++i)
    {
        int start = interval[i].first;
        int end = interval[i].second;
         
        vis[start]++;
        vis[end + 1]--;
    }
 
    // Find the first missing value
    for(int i = 1; i < MAX; i++)
    {
        vis[i] += vis[i - 1];
        if (vis[i] == 0)
        {
            Console.Write(i + "\n");
            return;
        }
    }
}
 
// Driver code
public static void Main(String[] args)
{
    pair []interval = { new pair(0, 14),
                        new pair(86, 108),
                        new pair(22, 30),
                        new pair(5, 17) };
                         
    find_missing(interval);
}
}
 
// This code is contributed by Amit Katiyar

Javascript




<script>
  
// Javascript program to find the
// least non-overlapping number
// from a given set intervals
var MAX = 100005;
 
// function to find the smallest
// non-overlapping number
function find_missing(  interval)
{
    // create a visited array
    var vis = Array(MAX).fill(0);
 
    for (var i = 0; i < interval.length; ++i) {
        var start = interval[i][0];
        var end = interval[i][1];
        vis[start]++;
        vis[end + 1]--;
    }
 
    // find the first missing value
    for (var i = 1; i < MAX; i++) {
        vis[i] += vis[i - 1];
        if (!vis[i]) {
            document.write( i + "<br>");
            return;
        }
    }
}
// Driver function
var interval
    = [ [ 0, 14 ], [ 86, 108 ],
        [ 22, 30 ], [ 5, 17 ] ];
find_missing(interval);
 
</script>
Output: 
18

 

Time Complexity: O (N) 
Auxiliary Space: O (MAX)
However, this approach will also not work if the interval coordinates are up to 10 9.

Efficient Approach: 

  1. Sort the range by their start-coordinate and for each next range.
  2. Check if the starting point is greater than the maximum end-coordinate encountered so far, then a missing number can be found, and it will be previous_max + 1.

Illustration: 
Consider the following example: 
interval[][] = { { 0, 14 }, { 86, 108 }, { 22, 30 }, { 5, 17 } }; 
After sorting, interval[][] = { { 0, 14 }, { 5, 17 }, { 22, 30 }, { 86, 108 }}; 
Initial mx = 0 and after considering first interval mx = max(0, 15) = 15 
Since mx = 15 and 15 > 5 so after considering second interval mx = max(15, 18) = 18 
now 18 < 22 so 18 is least non-overlapping number.
 

Here is the implementation of the above approach:

C++




// C++ program to find the
// least non-overlapping number
// from a given set intervals
 
#include <bits/stdc++.h>
using namespace std;
 
// function to find the smallest
// non-overlapping number
void find_missing(
    vector<pair<int, int> > interval)
{
    // Sort the intervals based on their
    // starting value
    sort(interval.begin(), interval.end());
 
    int mx = 0;
 
    for (int i = 0; i < (int)interval.size(); ++i) {
 
        // check if any missing value exist
        if (interval[i].first > mx) {
            cout << mx;
            return;
        }
 
        else
            mx = max(mx, interval[i].second + 1);
    }
    // finally print the missing value
    cout << mx;
}
// Driver function
int main()
{
 
    vector<pair<int, int> > interval
        = { { 0, 14 }, { 86, 108 },
            { 22, 30 }, { 5, 17 } };
    find_missing(interval);
    return 0;
}

Java




// Java program to find the
// least non-overlapping number
// from a given set intervals
import java.util.*;
import java.io.*;
 
class GFG{
     
static class Pair implements Comparable<Pair>
{
    int start,end;
    Pair(int s, int e)
    {
        start = s;
        end = e;
    }
     
    public int compareTo(Pair p)
    {
        return this.start - p.start;
    }
}
 
// Function to find the smallest
// non-overlapping number
static void findMissing(ArrayList<Pair> interval)
{
     
    // Sort the intervals based on their
    // starting value
    Collections.sort(interval);
 
    int mx = 0;
 
    for(int i = 0; i < interval.size(); ++i)
    {
         
        // Check if any missing value exist
        if (interval.get(i).start > mx)
        {
            System.out.println(mx);
            return;
        }
        else
            mx = Math.max(mx, interval.get(i).end + 1);
    }
     
    // Finally print the missing value
    System.out.println(mx);
}
 
// Driver code
public static void main(String []args)
{
    ArrayList<Pair> interval = new ArrayList<>();
    interval.add(new Pair(0, 14));
    interval.add(new Pair(86, 108));
    interval.add(new Pair(22, 30));
    interval.add(new Pair(5, 17));
     
    findMissing(interval);
}
}
 
// This code is contributed by Ganeshchowdharysadanala

Python3




# Python3 program to find the
# least non-overlapping number
# from a given set intervals
 
# function to find the smallest
# non-overlapping number
def find_missing(interval):
 
    # Sort the intervals based 
    # on their starting value
    interval.sort()
 
    mx = 0
 
    for i in range (len(interval)):
 
        # Check if any missing
        # value exist
        if (interval[i][0] > mx):
            print (mx)
            return
        
        else:
            mx = max(mx,
                     interval[i][1] + 1)
 
    # Finally print the missing value
    print (mx)
 
# Driver code
if __name__ == "__main__":
 
    interval = [[0, 14], [86, 108],
                [22, 30], [5, 17]]
    find_missing(interval);
    
# This code is contributed by Chitranayal

C#




// C# program to find the
// least non-overlapping number
// from a given set intervals
using System;
using System.Collections.Generic;
class GFG{
     
class Pair : IComparable<Pair>
{
    public int start,end;
    public Pair(int s, int e)
    {
        start = s;
        end = e;
    }
     
    public int CompareTo(Pair p)
    {
        return this.start - p.start;
    }
}
 
// Function to find the smallest
// non-overlapping number
static void findMissing(List<Pair> interval)
{
     
    // Sort the intervals based on their
    // starting value
    interval.Sort();
    int mx = 0;
    for(int i = 0; i < interval.Count; ++i)
    {
         
        // Check if any missing value exist
        if (interval[i].start > mx)
        {
            Console.WriteLine(mx);
            return;
        }
        else
            mx = Math.Max(mx, interval[i].end + 1);
    }
     
    // Finally print the missing value
    Console.WriteLine(mx);
}
 
// Driver code
public static void Main(String []args)
{
    List<Pair> interval = new List<Pair>();
    interval.Add(new Pair(0, 14));
    interval.Add(new Pair(86, 108));
    interval.Add(new Pair(22, 30));
    interval.Add(new Pair(5, 17));
     
    findMissing(interval);
}
}
 
// This code is contributed by shikhasingrajput

Javascript




<script>
// Javascript program to find the
// least non-overlapping number
// from a given set intervals
 
// Function to find the smallest
// non-overlapping number
function findMissing(interval)
{
 
    // Sort the intervals based on their
    // starting value
    interval.sort(function(a,b){return a[0]-b[0];});
    let mx = 0;
    for(let i = 0; i < interval.length; ++i)
    {
          
        // Check if any missing value exist
        if (interval[i][0] > mx)
        {
            document.write(mx+"<br>");
            return;
        }
        else
            mx = Math.max(mx, interval[i][1] + 1);
    }
      
    // Finally print the missing value
    document.write(mx);
}
 
// Driver code
let interval = [[0, 14], [86, 108],
                [22, 30], [5, 17]];
 
findMissing(interval);
                 
// This code is contributed by avanitrachhadiya2155.
</script>

Output: 

18

Time Complexity: O (N * logN) 
Auxiliary Space: O (1)


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!