# Maximal Disjoint Intervals

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

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:

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

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:

1. Sort the intervals, with respect to their end points.
2. 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.
3. 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++

 `// C++ implementation of the approach``#include ``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 > list)``{` `    ``// Sort the list of intervals``    ``sort(list.begin(), list.end(), sortbysec);` `    ``// First Interval will always be``    ``// included in set``    ``cout << ``"["` `<< list.first << ``", "``         ``<< list.second << ``"]"` `<< endl;` `    ``// End point of first interval``    ``int` `r1 = list.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 > intervals = { { 1, 4 },``                                          ``{ 2, 3 },``                                          ``{ 4, 6 },``                                          ``{ 8, 9 } };``    ``maxDisjointIntervals(intervals);` `    ``return` `0;``}`

## Java

 `// Java implementation of the approach``import` `java.util.*;``class` `GFG``{``    ``static` `class` `Pair ``implements` `Comparable``    ``{``        ``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

 `# 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`

## Javascript

 ``
Output:
```[2, 3]
[4, 6]
[8, 9]```

My Personal Notes arrow_drop_up