Given a set **S** of size **N **(*1 ≤ N ≤ 1e5*) consisting of intervals, the task is to find the minimum intervals required to be removed from the set such that any one of the remaining intervals becomes equal to the union of this set.

**Examples:**

Input:S = {[1, 3], [4, 12], [5, 8], [13, 20]}Output:2Explanation:

Removing the intervals [1, 3] and [13, 20] modifies the set to { [4, 12], [5, 8]}. The interval [4, 12] is the union of the set.

Input :S = {[1, 2], [1, 10], [4, 8], [3, 7]}Output:0Explanation:

Union of the given set = {[1, 10]}, which is already present in the set. Therefore, no removals required.

**Approach :** The problem can be solved based on the following observation:

Observation:To make any interval equal to the union of the set, the set must contain an interval[L, R]such that all the remaining intervals have their left boundary greater than equal toLand right boundary less than equal toR.

Follow the steps below to solve the problem:

- Traverse the given set of intervals.
- For every interval in the Set, find all the intervals which have their left boundary greater than or equal to its left boundary as well as have their right boundary less than or equal to its right boundary. Store the count of such intervals in a variable, say
**Count**. - Find the minimum value of all
**N – Count**(since**N – Count**would give the number of intervals deleted)values for each interval. - Print the minimum value obtained as the required answer.

Below is the implementation of above approach :

## C++

`// C++ implementaion of the above approach` `#include <bits/stdc++.h>` `using` `namespace` `std;` `// Function to count minimum number of removals` `// required to make an interval equal to the` `// union of the given Set` `int` `findMinDeletions(vector<pair<` `int` `, ` `int` `> >& v,` ` ` `int` `n)` `{` ` ` `// Stores the minimum number of removals` ` ` `int` `minDel = INT_MAX;` ` ` `// Traverse the Set` ` ` `for` `(` `int` `i = 0; i < n; i++) {` ` ` `// Left Boundary` ` ` `int` `L = v[i].first;` ` ` `// Right Boundary` ` ` `int` `R = v[i].second;` ` ` `// Stores count of intervals` ` ` `// lying within current interval` ` ` `int` `Count = 0;` ` ` `// Traverse over all remaining intervals` ` ` `for` `(` `int` `j = 0; j < n; j++) {` ` ` `// Check if interval lies within` ` ` `// the current interval` ` ` `if` `(v[j].first >= L && v[j].second <= R) {` ` ` `// Increase count` ` ` `Count += 1;` ` ` `}` ` ` `}` ` ` `// Update minimum removals required` ` ` `minDel = min(minDel, n - Count);` ` ` `}` ` ` `return` `minDel;` `}` `// Driver Code` `int` `main()` `{` ` ` `vector<pair<` `int` `, ` `int` `> > v;` ` ` `v.push_back({ 1, 3 });` ` ` `v.push_back({ 4, 12 });` ` ` `v.push_back({ 5, 8 });` ` ` `v.push_back({ 13, 20 });` ` ` `int` `N = v.size();` ` ` `// Returns the minimum removals` ` ` `cout << findMinDeletions(v, N);` ` ` `return` `0;` `}` |

## Java

`// Java implementaion of the above approach` `import` `java.util.*;` `class` `GFG{` `// Function to count minimum number of removals` `// required to make an interval equal to the` `// union of the given Set` `static` `int` `findMinDeletions(` `int` `[][]v,` ` ` `int` `n)` `{` ` ` ` ` `// Stores the minimum number of removals` ` ` `int` `minDel = Integer.MAX_VALUE;` ` ` `// Traverse the Set` ` ` `for` `(` `int` `i = ` `0` `; i < n; i++)` ` ` `{` ` ` `// Left Boundary` ` ` `int` `L = v[i][` `0` `];` ` ` `// Right Boundary` ` ` `int` `R = v[i][` `1` `];` ` ` `// Stores count of intervals` ` ` `// lying within current interval` ` ` `int` `Count = ` `0` `;` ` ` `// Traverse over all remaining intervals` ` ` `for` `(` `int` `j = ` `0` `; j < n; j++)` ` ` `{` ` ` `// Check if interval lies within` ` ` `// the current interval` ` ` `if` `(v[j][` `0` `] >= L && v[j][` `1` `] <= R)` ` ` `{` ` ` `// Increase count` ` ` `Count += ` `1` `;` ` ` `}` ` ` `}` ` ` `// Update minimum removals required` ` ` `minDel = Math.min(minDel, n - Count);` ` ` `}` ` ` `return` `minDel;` `}` `// Driver Code` `public` `static` `void` `main(String[] args)` `{` ` ` `int` `[][]v = {{ ` `1` `, ` `3` `},` ` ` `{ ` `4` `, ` `12` `},` ` ` `{ ` `5` `, ` `8` `},` ` ` `{ ` `13` `, ` `20` `}};` ` ` `int` `N = v.length;` ` ` `// Returns the minimum removals` ` ` `System.out.print(findMinDeletions(v, N));` `}` `}` `// This code is contributed by 29AjayKumar` |

## Python3

`# Python3 implementaion of the above approach` `# Function to count minimum number of removals` `# required to make an interval equal to the` `# union of the given Set` `def` `findMinDeletions(v, n):` ` ` ` ` `# Stores the minimum number of removals` ` ` `minDel ` `=` `10` `*` `*` `18` ` ` `# Traverse the Set` ` ` `for` `i ` `in` `range` `(n):` ` ` `# Left Boundary` ` ` `L ` `=` `v[i][` `0` `]` ` ` `# Right Boundary` ` ` `R ` `=` `v[i][` `1` `]` ` ` `# Stores count of intervals` ` ` `# lying within current interval` ` ` `Count ` `=` `0` ` ` `# Traverse over all remaining intervals` ` ` `for` `j ` `in` `range` `(n):` ` ` `# Check if interval lies within` ` ` `# the current interval` ` ` `if` `(v[j][` `1` `] >` `=` `L ` `and` `v[j][` `0` `] <` `=` `R):` ` ` ` ` `# Increase count` ` ` `Count ` `+` `=` `1` ` ` `# Update minimum removals required` ` ` `minDel ` `=` `min` `(minDel, n ` `-` `Count)` ` ` `return` `minDel` `# Driver Code` `if` `__name__ ` `=` `=` `'__main__'` `:` ` ` `v ` `=` `[]` ` ` `v.append([` `1` `, ` `3` `])` ` ` `v.append([` `4` `, ` `12` `])` ` ` `v.append([` `5` `, ` `8` `])` ` ` `v.append([` `13` `, ` `2` `])` ` ` `N ` `=` `len` `(v)` ` ` `# Returns the minimum removals` ` ` `print` `(findMinDeletions(v, N))` `# This code is contributed by mohit kumar 29` |

## C#

`// C# implementaion of the above approach` `using` `System;` `public` `class` `GFG{` `// Function to count minimum number of removals` `// required to make an interval equal to the` `// union of the given Set` `static` `int` `findMinDeletions(` `int` `[,]v,` ` ` `int` `n)` `{` ` ` ` ` `// Stores the minimum number of removals` ` ` `int` `minDel = ` `int` `.MaxValue;` ` ` `// Traverse the Set` ` ` `for` `(` `int` `i = 0; i < n; i++)` ` ` `{` ` ` `// Left Boundary` ` ` `int` `L = v[i,0];` ` ` `// Right Boundary` ` ` `int` `R = v[i,1];` ` ` `// Stores count of intervals` ` ` `// lying within current interval` ` ` `int` `Count = 0;` ` ` `// Traverse over all remaining intervals` ` ` `for` `(` `int` `j = 0; j < n; j++)` ` ` `{` ` ` `// Check if interval lies within` ` ` `// the current interval` ` ` `if` `(v[j,0] >= L && v[j,1] <= R)` ` ` `{` ` ` `// Increase count` ` ` `Count += 1;` ` ` `}` ` ` `}` ` ` `// Update minimum removals required` ` ` `minDel = Math.Min(minDel, n - Count);` ` ` `}` ` ` `return` `minDel;` `}` `// Driver Code` `public` `static` `void` `Main(String[] args)` `{` ` ` `int` `[,]v = {{ 1, 3 },` ` ` `{ 4, 12 },` ` ` `{ 5, 8 },` ` ` `{ 13, 20 }};` ` ` `int` `N = v.GetLength(0);` ` ` `// Returns the minimum removals` ` ` `Console.Write(findMinDeletions(v, N));` `}` `}` ` ` `// This code is contributed by 29AjayKumar` |

**Output:**

2

**Time Complexity:** O(N^{2})**Auxiliary space:** O(1)

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.