Given a set of N intervals, the task is to find the maximal set of mutually disjoint intervals. Two intervals [i, j] & [k, l] are said to be disjoint if they do not have any point in common.
Examples:
Input: intervals[][] = {{1, 4}, {2, 3}, {4, 6}, {8, 9}}
Output:
[2, 3]
[4, 6]
[8, 9]
Intervals sorted w.r.t. end points = {{2, 3}, {1, 4}, {4, 6}, {8, 9}}
Intervals [2, 3] and [1, 4] overlap.
We must include [2, 3] because if [1, 4] is included then
we cannot include [4, 6].
Input: intervals[][] = {{1, 9}, {2, 3}, {5, 7}}
Output:
[2, 3]
[5, 7]
Approach:
- Sort the intervals, with respect to their end points.
- Now, traverse through all the intervals, if we get two overlapping intervals, then greedily choose the interval with lower end point since, choosing it will ensure that intervals further can be accommodated without any overlap.
- Apply the same procedure for all the intervals and print all the intervals which satisfy the above criteria.
Below is the implementation of the above approach:
// C++ implementation of the approach #include <bits/stdc++.h> using namespace std;
#define ll long long int // Function to sort the vector elements // by second element of pairs bool sortbysec( const pair< int , int >& a,
const pair< int , int >& b)
{ return (a.second < b.second);
} // Function to find maximal disjoint set void maxDisjointIntervals(vector<pair< int , int > > list)
{ // Sort the list of intervals
sort(list.begin(), list.end(), sortbysec);
// First Interval will always be
// included in set
cout << "[" << list[0].first << ", "
<< list[0].second << "]" << endl;
// End point of first interval
int r1 = list[0].second;
for ( int i = 1; i < list.size(); i++) {
int l1 = list[i].first;
int r2 = list[i].second;
// Check if given interval overlap with
// previously included interval, if not
// then include this interval and update
// the end point of last added interval
if (l1 > r1) {
cout << "[" << l1 << ", "
<< r2 << "]" << endl;
r1 = r2;
}
}
} // Driver code int main()
{ int N = 4;
vector<pair< int , int > > intervals = { { 1, 4 },
{ 2, 3 },
{ 4, 6 },
{ 8, 9 } };
maxDisjointIntervals(intervals);
return 0;
} |
// Java implementation of the approach import java.io.*;
import java.util.*;
public class GFG
{ static class Pair implements Comparable<Pair>
{
int first, second;
Pair( int f, int s)
{
first = f;
second = s;
}
@Override
// Function to sort the vector elements
// by second element of Pairs
public int compareTo(Pair o)
{
if ( this .second > o.second)
return 1 ;
else if ( this .second == o.second)
return 0 ;
return - 1 ;
}
}
// Function to find maximal disjoint set static void maxDisjointIntervals(Pair []list)
{ // Sort the list of intervals
Collections.sort(Arrays.asList(list));
// First Interval will always be
// included in set
System.out.print( "[" + list[ 0 ].first+ ", "
+ list[ 0 ].second+ "]" + "\n" );
// End point of first interval
int r1 = list[ 0 ].second;
for ( int i = 1 ; i < list.length; i++) {
int l1 = list[i].first;
int r2 = list[i].second;
// Check if given interval overlap with
// previously included interval, if not
// then include this interval and update
// the end point of last added interval
if (l1 > r1) {
System.out.print( "[" + l1+ ", "
+ r2+ "]" + "\n" );
r1 = r2;
}
}
} // Driver code public static void main(String[] args)
{ int N = 4 ;
Pair []intervals = { new Pair( 1 , 4 ),
new Pair( 2 , 3 ),
new Pair( 4 , 6 ),
new Pair( 8 , 9 ) };
maxDisjointIntervals(intervals);
} } // This code is contributed by Princi Singh |
# Python3 implementation of the approach # Function to find maximal disjoint set def maxDisjointIntervals(list_):
# Lambda function to sort the list
# elements by second element of pairs
list_.sort(key = lambda x: x[ 1 ])
# First interval will always be
# included in set
print ( "[" , list_[ 0 ][ 0 ], ", " , list_[ 0 ][ 1 ], "]" )
# End point of first interval
r1 = list_[ 0 ][ 1 ]
for i in range ( 1 , len (list_)):
l1 = list_[i][ 0 ]
r2 = list_[i][ 1 ]
# Check if given interval overlap with
# previously included interval, if not
# then include this interval and update
# the end point of last added interval
if l1 > r1:
print ( "[" , l1, ", " , r2, "]" )
r1 = r2
# Driver code if __name__ = = "__main__" :
N = 4
intervals = [ [ 1 , 4 ], [ 2 , 3 ],
[ 4 , 6 ], [ 8 , 9 ] ]
# Call the function
maxDisjointIntervals(intervals)
# This code is contributed by Tokir Manva |
// C# implementation of the approach using System;
using System.Collections.Generic;
class Program
{ static void Main( string [] args)
{
int N = 4;
List<Tuple< int , int >> intervals = new List<Tuple< int , int >>()
{
new Tuple< int , int >(1, 4),
new Tuple< int , int >(2, 3),
new Tuple< int , int >(4, 6),
new Tuple< int , int >(8, 9)
};
MaxDisjointIntervals(intervals);
}
private static void MaxDisjointIntervals(List<Tuple< int , int >> list)
{
// Sort the list of intervals by second element of tuples
list.Sort((a, b) => a.Item2.CompareTo(b.Item2));
// First Interval will always be included in set
Console.WriteLine( "[" + list[0].Item1 + ", " + list[0].Item2 + "]" );
// End point of first interval
int r1 = list[0].Item2;
for ( int i = 1; i < list.Count; i++)
{
int l1 = list[i].Item1;
int r2 = list[i].Item2;
// Check if given interval overlap with
// previously included interval, if not
// then include this interval and update
// the end point of last added interval
if (l1 > r1)
{
Console.WriteLine( "[" + l1 + ", " + r2 + "]" );
r1 = r2;
}
}
}
} |
<script> // Javascript implementation of the approach // Function to find maximal disjoint set function maxDisjointIntervals(list)
{ // Sort the list of intervals
list.sort((a,b)=> a[1]-b[1]);
// First Interval will always be
// included in set
document.write( "[" + list[0][0] + ", "
+ list[0][1] + "]" + "<br>" );
// End point of first interval
var r1 = list[0][1];
for ( var i = 1; i < list.length; i++) {
var l1 = list[i][0];
var r2 = list[i][1];
// Check if given interval overlap with
// previously included interval, if not
// then include this interval and update
// the end point of last added interval
if (l1 > r1) {
document.write( "[" + l1 + ", "
+ r2 + "]" + "<br>" );
r1 = r2;
}
}
} // Driver code var N = 4;
var intervals = [ [ 1, 4 ],
[ 2, 3 ],
[ 4, 6 ],
[ 8, 9 ] ];
maxDisjointIntervals(intervals); </script> |
[2, 3] [4, 6] [8, 9]
Time Complexity: O(nlogn)
Auxiliary Space: O(1)