# Minimum count of subintervals to cover a given time duration

Last Updated : 27 Apr, 2023

Given an array of intervals[], the task is to find the minimum count of subintervals needed to cover a given time duration. Each interval represents a segment of time that starts at a specific point in time (start time) and ends at another specific point in time (end time). The intervals may overlap and have varying lengths. If it’s impossible to cover the entire duration, return -1.

Examples:

Input: Intervals[] = [[0, 1], [6, 8], [0, 2], [5, 6], [0, 4], [0, 3], [6, 7], [1, 3], [4, 7], [1, 4], [2, 5], [2, 6], [3, 4], [4, 5], [5, 7], [6, 9]], timeDuration = 9
Output: 3
Explanation: We can take subintervals [0, 4], [4, 7], and [6, 9]. There are also many subintervals but this is the maximum among them.

Input: Intervals[] = [[0, 2], [4, 6], [8, 10], [1, 9], [1, 5], [5, 9]], timeDuration = 10
Output: 3
Explanation: We take the subintervals [0, 2], [8, 10], [1, 9]; a total of 3 subintervals.

Approach: This can be solved with the following idea:

Using Dynamic Programming, and sorting the intervals on the basis of the start time, we can get how many intervals it will cover if started from a particular time up to time duration.

Below are the steps involved in the implementation of the code:

• First, we sort the given intervals in non-decreasing order of their start times.
• We create a 1-D DP array dp with size time+1, where time is the given time duration.
• We initialize all elements of dp to INT_MAX – 1, except dp[0] = 0, since we can cover 0-time duration with 0 intervals.
• If the current time duration falls in any interval, we update dp[i] as min(dp[i], dp[interval[0]] + 1), where interval[0] is the start time of the interval and dp[interval[0]] + 1 means we are adding the current interval to the number of subintervals needed to cover time duration i.
• Finally, we return dp[time] if dp[time] < INT_MAX – 1, since dp[time] will store the minimum number of subintervals needed to cover the given time duration. Otherwise, we return -1, indicating that it is not possible to cover the given time duration using the given intervals.

Below is the implementation of the above idea:

## C++

 `// C++ Implementation of code` `#include ` `using` `namespace` `std;`   `// Function to find minimum subintervals` `int` `CountSubintervals(vector >& Intervals,` `                      ``int` `time``)` `{`   `    ``// Sort the intervals in increasing` `    ``// order of start time` `    ``sort(Intervals.begin(), Intervals.end());`   `    ``// Create a dp table of size time + 1` `    ``vector<``int``> dp(``time` `+ 1, INT_MAX - 1);`   `    ``dp[0] = 0;` `    ``for` `(``int` `i = 1; i <= ``time``; i++) {` `        ``for` `(``auto``& interval : Intervals) {`   `            ``// If the current time value i` `            ``// is within the current interval,` `            ``// update the current dp cell` `            ``// with the minimum value` `            ``// between the current dp` `            ``// cell and the dp cell of the` `            ``// interval start time plus 1` `            ``if` `(interval[0] <= i && i <= interval[1]) {` `                ``dp[i] = min(dp[i], dp[interval[0]] + 1);` `            ``}` `        ``}` `    ``}`   `    ``// If the last dp cell has a value of` `    ``// INT_MAX - 1, return -1, otherwise` `    ``// return the value of the last dp cell` `    ``return` `dp[``time``] == INT_MAX - 1 ? -1 : dp[``time``];` `}`   `// Driver code` `int` `main()` `{` `    ``vector > Intervals` `        ``= { { 0, 1 }, { 6, 8 }, { 0, 2 }, { 5, 6 }, { 0, 4 }, { 0, 3 }, { 6, 7 }, { 1, 3 }, { 4, 7 }, { 1, 4 }, { 2, 5 }, { 2, 6 }, { 3, 4 }, { 4, 5 }, { 5, 7 }, { 6, 9 } };` `    ``int` `timeDuration = 9;`   `    ``// Function call` `    ``int` `result = CountSubintervals(Intervals, timeDuration);` `    ``cout << result << endl;` `    ``return` `0;` `}`

## Java

 `// Java Implementation of code` `import` `java.util.*;`   `class` `GFG {`   `    ``// Function to find minimum subintervals` `    ``public` `static` `int` `    ``CountSubintervals(List > Intervals,` `                      ``int` `time)` `    ``{`   `        ``// Sort the intervals in increasing` `        ``// order of start time` `        ``Collections.sort(` `            ``Intervals, ``new` `Comparator >() {` `                ``public` `int` `compare(List a,` `                                   ``List b)` `                ``{` `                    ``return` `a.get(``0``) - b.get(``0``);` `                ``}` `            ``});`   `        ``// Create a dp table of size time + 1` `        ``List dp` `            ``= ``new` `ArrayList<>(Collections.nCopies(` `                ``time + ``1``, Integer.MAX_VALUE - ``1``));`   `        ``dp.set(``0``, ``0``);` `        ``for` `(``int` `i = ``1``; i <= time; i++) {` `            ``for` `(List interval : Intervals) {`   `                ``// If the current time value i` `                ``// is within the current interval,` `                ``// update the current dp cell` `                ``// with the minimum value` `                ``// between the current dp` `                ``// cell and the dp cell of the` `                ``// interval start time plus 1` `                ``if` `(interval.get(``0``) <= i` `                    ``&& i <= interval.get(``1``)) {` `                    ``dp.set(i,` `                           ``Math.min(dp.get(i),` `                                    ``dp.get(interval.get(``0``))` `                                        ``+ ``1``));` `                ``}` `            ``}` `        ``}`   `        ``// If the last dp cell has a value of` `        ``// Integer.MAX_VALUE - 1, return -1, otherwise` `        ``// return the value of the last dp cell` `        ``return` `dp.get(time) == Integer.MAX_VALUE - ``1` `            ``? -``1` `            ``: dp.get(time);` `    ``}`   `    ``// Driver code` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``List > Intervals = Arrays.asList(` `            ``Arrays.asList(``0``, ``1``), Arrays.asList(``6``, ``8``),` `            ``Arrays.asList(``0``, ``2``), Arrays.asList(``5``, ``6``),` `            ``Arrays.asList(``0``, ``4``), Arrays.asList(``0``, ``3``),` `            ``Arrays.asList(``6``, ``7``), Arrays.asList(``1``, ``3``),` `            ``Arrays.asList(``4``, ``7``), Arrays.asList(``1``, ``4``),` `            ``Arrays.asList(``2``, ``5``), Arrays.asList(``2``, ``6``),` `            ``Arrays.asList(``3``, ``4``), Arrays.asList(``4``, ``5``),` `            ``Arrays.asList(``5``, ``7``), Arrays.asList(``6``, ``9``));` `        ``int` `timeDuration = ``9``;`   `        ``// Function call` `        ``int` `result` `            ``= CountSubintervals(Intervals, timeDuration);` `        ``System.out.println(result);` `    ``}` `}` `// This code is contributed by prasad264`

## Python3

 `# Python Implementation of code`   `# Function to find minimum subintervals` `def` `CountSubintervals(Intervals, time):`   `    ``# Sort the intervals in increasing` `    ``# order of start time` `    ``Intervals.sort()`   `    ``# Create a dp table of size time + 1` `    ``dp ``=` `[``float``(``'inf'``)] ``*` `(time ``+` `1``)`   `    ``dp[``0``] ``=` `0` `    ``for` `i ``in` `range``(``1``, time ``+` `1``):` `        ``for` `interval ``in` `Intervals:`   `            ``# If the current time value i` `            ``# is within the current interval,` `            ``# update the current dp cell` `            ``# with the minimum value` `            ``# between the current dp` `            ``# cell and the dp cell of the` `            ``# interval start time plus 1` `            ``if` `interval[``0``] <``=` `i ``and` `i <``=` `interval[``1``]:` `                ``dp[i] ``=` `min``(dp[i], dp[interval[``0``]] ``+` `1``)`   `    ``# If the last dp cell has a value of` `    ``# INT_MAX - 1, return -1, otherwise` `    ``# return the value of the last dp cell` `    ``return` `-``1` `if` `dp[time] ``=``=` `float``(``'inf'``) ``else` `dp[time]`     `# Driver code` `if` `__name__ ``=``=` `'__main__'``:` `    ``Intervals ``=` `[[``0``, ``1``], [``6``, ``8``], [``0``, ``2``], [``5``, ``6``], [``0``, ``4``], [``0``, ``3``], [``6``, ``7``], [` `        ``1``, ``3``], [``4``, ``7``], [``1``, ``4``], [``2``, ``5``], [``2``, ``6``], [``3``, ``4``], [``4``, ``5``], [``5``, ``7``], [``6``, ``9``]]` `    ``timeDuration ``=` `9`   `    ``# Function call` `    ``result ``=` `CountSubintervals(Intervals, timeDuration)` `    ``print``(result)`   `# This code is contributed by Tapesh(tapeshdua420)`

## C#

 `// C#Implementation of code`   `using` `System;` `using` `System.Collections.Generic;` `using` `System.Linq;`   `class` `Program` `{` `    ``// Function to find minimum subintervals` `    ``static` `int` `CountSubintervals(List> intervals, ``int` `time)` `    ``{` `        ``// Sort the intervals in increasing order of start time` `        ``intervals.Sort((x, y) => x[0].CompareTo(y[0]));`   `        ``// Create a dp table of size time + 1` `        ``List<``int``> dp = Enumerable.Repeat(``int``.MaxValue - 1, time + 1).ToList();`   `        ``dp[0] = 0;` `        ``for` `(``int` `i = 1; i <= time; i++)` `        ``{` `            ``foreach` `(``var` `interval ``in` `intervals)` `            ``{` `                ``// If the current time value i is within the current interval,` `                ``// update the current dp cell with the minimum value between` `                ``// the current dp cell and the dp cell of the interval start time plus 1` `                ``if` `(interval[0] <= i && i <= interval[1])` `                ``{` `                    ``dp[i] = Math.Min(dp[i], dp[interval[0]] + 1);` `                ``}` `            ``}` `        ``}`   `        ``// If the last dp cell has a value of int.MaxValue - 1, return -1,` `        ``// otherwise return the value of the last dp cell` `        ``return` `dp[time] == ``int``.MaxValue - 1 ? -1 : dp[time];` `    ``}`   `    ``static` `void` `Main(``string``[] args)` `    ``{` `        ``List> intervals = ``new` `List> {` `            ``new` `List<``int``>{0, 1}, ``new` `List<``int``>{6, 8}, ``new` `List<``int``>{0, 2},` `            ``new` `List<``int``>{5, 6}, ``new` `List<``int``>{0, 4}, ``new` `List<``int``>{0, 3},` `            ``new` `List<``int``>{6, 7}, ``new` `List<``int``>{1, 3}, ``new` `List<``int``>{4, 7},` `            ``new` `List<``int``>{1, 4}, ``new` `List<``int``>{2, 5}, ``new` `List<``int``>{2, 6},` `            ``new` `List<``int``>{3, 4}, ``new` `List<``int``>{4, 5}, ``new` `List<``int``>{5, 7},` `            ``new` `List<``int``>{6, 9}` `        ``};` `        ``int` `timeDuration = 9;`   `        ``// Function call` `        ``int` `result = CountSubintervals(intervals, timeDuration);` `        ``Console.WriteLine(result);` `    ``}` `}`

## Javascript

 `function` `CountSubintervals(Intervals, time)` `{`   `  ``// Sort the intervals in increasing order of start time` `  ``Intervals.sort((a, b) => a[0] - b[0]);`   `  ``// Create a dp table of size time + 1` `  ``const dp = ``new` `Array(time + 1).fill(Number.MAX_SAFE_INTEGER - 1);`   `  ``dp[0] = 0;` `  ``for` `(let i = 1; i <= time; i++) ` `  ``{` `    ``for` `(let interval of Intervals)` `    ``{` `    `  `      ``// If the current time value i is within the current interval,` `      ``// update the current dp cell with the minimum value` `      ``// between the current dp cell and the dp cell of the` `      ``// interval start time plus 1` `      ``if` `(interval[0] <= i && i <= interval[1]) {` `        ``dp[i] = Math.min(dp[i], dp[interval[0]] + 1);` `      ``}` `    ``}` `  ``}`   `  ``// If the last dp cell has a value of Number.MAX_SAFE_INTEGER - 1, return -1,` `  ``// otherwise return the value of the last dp cell` `  ``return` `dp[time] == Number.MAX_SAFE_INTEGER - 1 ? -1 : dp[time];` `}`   `// Driver code` `const Intervals = [[0, 1],[6, 8],[0, 2],[5, 6],[0, 4],` `[0, 3],[6, 7],[1, 3],[4, 7],[1, 4],[2, 5],` `[2, 6],[3, 4],[4, 5],[5, 7],[6, 9], ];` `const timeDuration = 9;`   `// Function call` `const result = CountSubintervals(Intervals, timeDuration);` `console.log(result);`

Output

`3`

Time Complexity: O(T*N)
Auxiliary Space: O(T)

Previous
Next