GFG App
Open App
Browser
Continue

# Add minimum sized interval such that all intervals merge into one

Given a 2D array arr of size N which represents an interval [start, end] inclusive where (start < end), the task is to add only one interval of minimum size (size = end – start) into the given arr, such that merging all the interval result in only one interval.

Examples:

Input: arr= {{12, 20}, {24, 100}}
Output: 4
Explanation: We can add the interval [20, 24] which is the smallest possible interval.

Input: arr= {{21, 43}, {26, 29}, {46, 70}}
Output: 3

### Approach: Greedy algorithm:

The idea to solve this problem is that we’ll try to add intervals greedily. Since we know there is a single interval missing, we want to track the gap when adding the intervals in a sorted manner from start to end.

We can do this by keeping the track of the last interval’s end and new interval’s begin when the previous and the current intervals are non overlapping.

Follow the steps below to implement the above idea:

• First sort the intervals based on start position.
• Keep variables “start” and “end”, which stores the starting and ending point of our required answer interval. and an extra variable “prev” for storing the last occurred interval in the iteration that is needed to merge for the next upcoming intervals.
• Check if intervals overlapped or not.
• If Intervals are not overlapped
• Keep track of “start” and “end”
• Update the “prev” with current interval arr[i].
• Update “prev” after merging the overlapping intervals
• Return the size of the interval using the end-start.

Below is the implementation of the above approach:

## C++

 `// C++ code for the above approach: ` ` `  `#include ` `using` `namespace` `std; ` ` `  `// Function return the minimum size of ` `// interval needed to add ` `int` `minInterval(vector >& arr) ` `{ ` `    ``// Sort the array on start basis ` `    ``sort(arr.begin(), arr.end()); ` ` `  `    ``int` `n = arr.size(), start = -1, end = -1; ` ` `  `    ``// If size of given interval is one or ` `    ``// zero then return 0. ` `    ``if` `(n == 0 || n == 1) ` `        ``return` `0; ` ` `  `    ``// prev store the previous interval ` `    ``auto` `prev = arr[0]; ` ` `  `    ``for` `(``int` `i = 1; i < n; i++) { ` ` `  `        ``// If intervals are not ` `        ``// overlapping ` `        ``if` `(max(arr[i][0], prev[0]) ` `            ``> min(arr[i][1], prev[1])) { ` ` `  `            ``// Keep track of start and end ` `            ``// intervals where intervals ` `            ``// do not overlap ` `            ``if` `(start == -1) { ` `                ``start = prev[1]; ` `                ``end = arr[i][0]; ` `            ``} ` `            ``else` `{ ` `                ``end = arr[i][0]; ` `            ``} ` ` `  `            ``// Update the previous ` `            ``// interval ` `            ``prev = arr[i]; ` `        ``} ` `        ``else` `{ ` ` `  `            ``// Update the previous interval ` `            ``// after considering these ` `            ``// interval are overlapping ` `            ``prev = { min(arr[i][0], prev[0]), ` `                     ``max(arr[i][1], prev[1]) }; ` `        ``} ` `    ``} ` ` `  `    ``// Return the size of interval. ` `    ``return` `end - start; ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``vector > arr = { { 12, 20 }, { 24, 100 } }; ` ` `  `    ``// Function call ` `    ``int` `result = minInterval(arr); ` `    ``cout << result << endl; ` `    ``return` `0; ` `}`

## Java

 `// Java code for the above approach ` ` `  `import` `java.io.*; ` `import` `java.util.*; ` ` `  `class` `GFG { ` ` `  `    ``// Function return the minimum size of interval needed ` `    ``// to add ` `    ``static` `int` `minInterval(``int``[][] arr) ` `    ``{ ` ` `  `        ``int` `n = arr.length; ` `        ``int` `start = -``1``; ` `        ``int` `end = -``1``; ` ` `  `        ``// If size of given interval is one or zero then ` `        ``// return 0. ` `        ``if` `(n == ``0` `|| n == ``1``) { ` `            ``return` `0``; ` `        ``} ` ` `  `        ``// prev store the previous interval ` `        ``var prev = arr[``0``]; ` ` `  `        ``for` `(``int` `i = ``1``; i < n; i++) { ` `            ``// If intervals are not ` `            ``// overlapping ` `            ``if` `(Math.max(arr[i][``0``], prev[``0``]) ` `                ``> Math.min(arr[i][``1``], prev[``1``])) { ` ` `  `                ``// Keep track of start and end ` `                ``// intervals where intervals ` `                ``// do not overlap ` `                ``if` `(start == -``1``) { ` `                    ``start = prev[``1``]; ` `                    ``end = arr[i][``0``]; ` `                ``} ` `                ``else` `{ ` `                    ``end = arr[i][``0``]; ` `                ``} ` ` `  `                ``// Update the previous ` `                ``// interval ` `                ``prev = arr[i]; ` `            ``} ` `            ``else` `{ ` ` `  `                ``// Update the previous interval ` `                ``// after considering these ` `                ``// interval are overlapping ` `                ``prev = ``new` `int``[] { ` `                    ``Math.min(arr[i][``0``], prev[``0``]), ` `                    ``Math.max(arr[i][``1``], prev[``1``]) ` `                ``}; ` `            ``} ` `        ``} ` ` `  `        ``// Return the size of interval. ` `        ``return` `end - start; ` `    ``} ` ` `  `    ``public` `static` `void` `main(String[] args) ` `    ``{ ` `        ``int``[][] arr = { { ``12``, ``20` `}, { ``24``, ``100` `} }; ` ` `  `        ``// Function call ` `        ``int` `result = minInterval(arr); ` `        ``System.out.print(result); ` `    ``} ` `} ` ` `  `// This code is contributed by lokesh`

## Python3

 `# python code for the above approach: ` ` `  `# Function return the minimum size of ` `# interval needed to add ` ` `  ` `  `def` `minInterval(arr): ` ` `  `    ``# Sort the array on start basis ` `    ``arr.sort() ` ` `  `    ``n ``=` `len``(arr) ` `    ``start ``=` `-``1` `    ``end ``=` `-``1` ` `  `    ``# If size of given interval is one or ` `    ``# zero then return 0. ` `    ``if` `(n ``=``=` `0` `or` `n ``=``=` `1``): ` `        ``return` `0` ` `  `    ``# prev store the previous interval ` `    ``prev ``=` `arr[``0``] ` ` `  `    ``for` `i ``in` `range``(n): ` ` `  `        ``# If intervals are not ` `        ``# overlapping ` `        ``if` `(``max``(arr[i][``0``], prev[``0``]) > ``min``(arr[i][``1``], prev[``1``])): ` ` `  `            ``# Keep track of start and end ` `            ``# intervals where intervals ` `            ``# do not overlap ` `            ``if` `(start ``=``=` `-``1``): ` `                ``start ``=` `prev[``1``] ` `                ``end ``=` `arr[i][``0``] ` ` `  `            ``else``: ` `                ``end ``=` `arr[i][``0``] ` ` `  `            ``# Update the previous ` `            ``# interval ` `            ``prev ``=` `arr[i] ` ` `  `        ``else``: ` ` `  `            ``# Update the previous interval ` `            ``# after considering these ` `            ``# interval are overlapping ` `            ``prev ``=` `[``min``(arr[i][``0``], prev[``0``]), ``max``(arr[i][``1``], prev[``1``])] ` ` `  `    ``# Return the size of interval. ` `    ``return` `end ``-` `start ` ` `  ` `  `# Driver code ` ` `  `arr ``=` `[[``12``, ``20``], [``24``, ``100``]] ` ` `  `# Function call ` `result ``=` `minInterval(arr) ` `print``(result) `

## C#

 `using` `System; ` `using` `System.Collections.Generic; ` ` `  `public` `class` `GFG { ` ` `  `  ``static` `int` `minInterval(``int``[, ] arr) ` `  ``{ ` ` `  `    ``int` `n = arr.GetLength(0); ` `    ``int` `start = -1; ` `    ``int` `end = -1; ` ` `  `    ``// If size of given interval is one or zero then ` `    ``// return 0. ` `    ``if` `(n == 0 || n == 1) { ` `      ``return` `0; ` `    ``} ` ` `  `    ``// prev store the previous interval ` `    ``int``[] prev = ``new` `int``[arr.GetLength(1)]; ` `    ``for` `(``int` `i = 0; i < arr.GetLength(1); i++) { ` `      ``prev[i] = arr[0, i]; ` `    ``} ` ` `  `    ``for` `(``int` `i = 1; i < n; i++) { ` `      ``// If intervals are not ` `      ``// overlapping ` `      ``if` `(Math.Max(arr[i, 0], prev[0]) ` `          ``> Math.Min(arr[i, 1], prev[1])) { ` ` `  `        ``// Keep track of start and end ` `        ``// intervals where intervals ` `        ``// do not overlap ` `        ``if` `(start == -1) { ` `          ``start = prev[1]; ` `          ``end = arr[i, 0]; ` `        ``} ` `        ``else` `{ ` `          ``end = arr[i, 0]; ` `        ``} ` ` `  `        ``// Update the previous ` `        ``// interval ` `        ``for` `(``int` `j = 0; j < arr.GetLength(1); j++) { ` `          ``prev[j] = arr[i, j]; ` `        ``} ` `      ``} ` `      ``else` `{ ` ` `  `        ``// Update the previous interval ` `        ``// after considering these ` `        ``// interval are overlapping ` `        ``prev = ``new` `int``[] { ` `          ``Math.Min(arr[i, 0], prev[0]), ` `          ``Math.Max(arr[i, 1], prev[1]) ` `          ``}; ` `      ``} ` `    ``} ` ` `  `    ``// Return the size of interval. ` `    ``return` `end - start; ` `  ``} ` ` `  `  ``static` `public` `void` `Main() ` `  ``{ ` ` `  `    ``int``[, ] arr = { { 12, 20 }, { 24, 100 } }; ` ` `  `    ``// Function call ` `    ``int` `result = minInterval(arr); ` `    ``Console.WriteLine(result); ` `  ``} ` `} ` ` `  `// This code is contributed by ishankhandelwals.`

## Javascript

 ``

## PHP

 ` min(``\$arr``[``\$i``][1], ``\$prev``[1])) { ` ` `  `            ``// Keep track of start and end ` `            ``// intervals where intervals ` `            ``// do not overlap ` `            ``if` `(``\$start` `== -1) { ` `                ``\$start` `= ``\$prev``[1]; ` `                ``\$end` `= ``\$arr``[``\$i``][0]; ` `            ``} ` `            ``else` `{ ` `                ``\$end` `= ``\$arr``[``\$i``][0]; ` `            ``} ` ` `  `            ``// Update the previous ` `            ``// interval ` `            ``\$prev` `= ``\$arr``[``\$i``]; ` `        ``} ` `        ``else` `{ ` ` `  `            ``// Update the previous interval ` `            ``// after considering these ` `            ``// interval are overlapping ` `            ``\$prev` `= ``array``( min(``\$arr``[``\$i``][0], ``\$prev``[0]), ` `                            ``max(``\$arr``[``\$i``][1], ``\$prev``[1]) ); ` `        ``} ` `    ``} ` ` `  `    ``// Return the size of interval. ` `    ``return` `\$end` `- ``\$start``;  ` `} ` ` `  `// Driver code ` `\$arr` `= ``array``(``array``(12, 20), ``array``(24, 100)); ` ` `  `// Function call ` `\$result` `= minInterval(``\$arr``); ` `echo` `\$result``; ` ` `  `// This code is contributed by Kanishka Gupta ` `?> `

Output

`4`

Time Complexity: O(N * logN), This is due to sorting.
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up