Minimum distance to travel to cover all intervals

22 Jun, 2022
Given many intervals as ranges and our position. We need to find minimum distance to travel to reach such a point which covers all the intervals at once. 
Examples:  
Input : Intervals = [(0, 7), (2, 14), (4, 6)]
        Position = 3
Output : 1
We can reach position 4 by traveling
distance 1, at which all intervals will
be covered. So answer will be 1

Input : Intervals = [(1, 2), (2, 3), (3, 4)]
        Position = 2
Output : -1 
It is not possible to cover all intervals
at once at any point

Input : Intervals = [(1, 2), (2, 3), (1, 4)]
        Position = 2
Output : 0
All Intervals are covered at current 
position only so no need travel and
answer will be 0

All above examples are shown in below diagram.
We can solve this problem by concentrating only on endpoints. Since the requirement is to cover all intervals by reaching a point, all intervals must a share a point for answer to exist. Even the interval with leftmost end point must overlap with the interval right most start point. First, we find right most start point and left most end point from all intervals. Then we can compare our position with these points to get the result which is explained below : 
If this right most start point is to the right of left most end point then it is not possible to cover all intervals simultaneously. (as in example 2)If our position is in mid between to right most start and left most end then there is no need to travel and all intervals will be covered by current position only (as in example 3)If our position is left to both points then we need to travel up to the rightmost start point and if our position is right to both points then we need to travel up to leftmost end point.
If this right most start point is to the right of left most end point then it is not possible to cover all intervals simultaneously. (as in example 2)
If our position is in mid between to right most start and left most end then there is no need to travel and all intervals will be covered by current position only (as in example 3)
If our position is left to both points then we need to travel up to the rightmost start point and if our position is right to both points then we need to travel up to leftmost end point.
Refer above diagram to understand these cases. As in the first example, right most start is 4 and left most end is 6, so we need to reach 4 from current position 3 to cover all intervals. 
Please see the below code for a better understanding.  
C++
Java
Python3
C#
Javascript
// C++ program to find minimum distance to// travel to cover all intervals#include <bits/stdc++.h>using namespace std; //  structure to store an intervalstruct Interval{    int start, end;    Interval(int start, int end) : start(start),                                       end(end)    {}}; //  Method returns minimum distance to travel// to cover all intervalsint minDistanceToCoverIntervals(Interval intervals[],                                       int N, int x){    int rightMostStart = INT_MIN;    int leftMostEnd = INT_MAX;     //  looping over all intervals to get right most    // start and left most end    for (int i = 0; i < N; i++)    {        if (rightMostStart < intervals[i].start)            rightMostStart = intervals[i].start;         if (leftMostEnd > intervals[i].end)            leftMostEnd = intervals[i].end;    }         int res;     /*  if rightmost start > leftmost end then all        intervals are not aligned and it is not        possible to cover all of them  */    if (rightMostStart > leftMostEnd)        res = -1;     //  if x is in between rightmoststart and    // leftmostend then no need to travel any distance    else if (rightMostStart <= x && x <= leftMostEnd)        res = 0;         //  choose minimum according to current position x    else        res = (x < rightMostStart) ? (rightMostStart - x) :                                     (x - leftMostEnd);         return res;} //  Driver code to test above methodsint main(){    int x = 3;    Interval intervals[] = {{0, 7}, {2, 14}, {4, 6}};    int N = sizeof(intervals) / sizeof(intervals[0]);     int res = minDistanceToCoverIntervals(intervals, N, x);    if (res == -1)        cout << "Not Possible to cover all intervals\n";    else        cout << res << endl;}
// Java program to find minimum distance// to travel to cover all intervalsimport java.util.*; class GFG{     // Structure to store an intervalstatic class Interval{    int start, end;    Interval(int start, int end)    {        this.start = start;        this.end = end;    }}; // Method returns minimum distance to// travel to cover all intervalsstatic int minDistanceToCoverIntervals(Interval intervals[],                                       int N, int x){    int rightMostStart = Integer.MIN_VALUE;    int leftMostEnd = Integer.MAX_VALUE;         // Looping over all intervals to get    // right most start and left most end    for(int i = 0; i < N; i++)    {        if (rightMostStart < intervals[i].start)            rightMostStart = intervals[i].start;         if (leftMostEnd > intervals[i].end)            leftMostEnd = intervals[i].end;    }         int res;     // If rightmost start > leftmost end then    // all intervals are not aligned and it    // is not possible to cover all of them     if (rightMostStart > leftMostEnd)        res = -1;             // If x is in between rightmoststart and    // leftmostend then no need to travel    // any distance    else if (rightMostStart <= x &&             x <= leftMostEnd)        res = 0;         // Choose minimum according to    // current position x    else        res = (x < rightMostStart) ?              (rightMostStart - x) :              (x - leftMostEnd);         return res;} //  Driver codepublic static void main(String[] args){    int x = 3;    Interval []intervals = { new Interval(0, 7),                             new Interval(2, 14),                             new Interval(4, 6) };    int N = intervals.length;     int res = minDistanceToCoverIntervals(        intervals, N, x);         if (res == -1)        System.out.print("Not Possible to " +                         "cover all intervals\n");    else        System.out.print(res + "\n");}} // This code is contributed by Rajput-Ji
# Python program to find minimum distance to# travel to cover all intervals #  Method returns minimum distance to travel# to cover all intervalsdef minDistanceToCoverIntervals(Intervals, N, x):    rightMostStart = Intervals[0][0]    leftMostStart = Intervals[0][1]     # looping over all intervals to get right most    # start and left most end    for curr in Intervals:        if rightMostStart < curr[0]:            rightMostStart = curr[0]        if leftMostStart > curr[1]:            leftMostStart = curr[1]     # if rightmost start > leftmost end then all    # intervals are not aligned and it is not    # possible to cover all of them    if rightMostStart > leftMostStart:        res = -1             # if x is in between rightmoststart and    # leftmostend then no need to travel any distance    else if rightMostStart <= x and x <= leftMostStart:        res = 0             # choose minimum according to current position x    else:        res = rightMostStart-x if x < rightMostStart else x-leftMostStart    return res # Driver code to test above methodsIntervals = [[0, 7], [2, 14], [4, 6]]N = len(Intervals)x = 3 res = minDistanceToCoverIntervals(Intervals, N, x)if res == -1:    print("Not Possible to cover all intervals")else:    print(res)     # This code is contributed by rj13to.
// C# program to find minimum distance// to travel to cover all intervalsusing System; class GFG{     // Structure to store an intervalpublic class Interval{    public int start, end;         public Interval(int start, int end)    {        this.start = start;        this.end = end;    }}; // Method returns minimum distance to// travel to cover all intervalsstatic int minDistanceToCoverIntervals(    Interval []intervals, int N, int x){    int rightMostStart = int.MinValue;    int leftMostEnd = int.MaxValue;         // Looping over all intervals to get    // right most start and left most end    for(int i = 0; i < N; i++)    {        if (rightMostStart < intervals[i].start)            rightMostStart = intervals[i].start;         if (leftMostEnd > intervals[i].end)            leftMostEnd = intervals[i].end;    }         int res;     // If rightmost start > leftmost end then    // all intervals are not aligned and it    // is not possible to cover all of them     if (rightMostStart > leftMostEnd)        res = -1;             // If x is in between rightmoststart and    // leftmostend then no need to travel    // any distance    else if (rightMostStart <= x &&             x <= leftMostEnd)        res = 0;         // Choose minimum according to    // current position x    else        res = (x < rightMostStart) ?              (rightMostStart - x) :              (x - leftMostEnd);         return res;} //  Driver codepublic static void Main(String[] args){    int x = 3;    Interval []intervals = { new Interval(0, 7),                             new Interval(2, 14),                             new Interval(4, 6) };    int N = intervals.Length;     int res = minDistanceToCoverIntervals(        intervals, N, x);         if (res == -1)        Console.Write("Not Possible to " +                      "cover all intervals\n");    else        Console.Write(res + "\n");}} // This code is contributed by shikhasingrajput
<script> // JavaScript program to find minimum distance to// travel to cover all intervals // Method returns minimum distance to travel// to cover all intervalsfunction minDistanceToCoverIntervals(Intervals, N, x){    let rightMostStart = Intervals[0][0]    let leftMostStart = Intervals[0][1]     // looping over all intervals to get right most    // start and left most end    for(let curr of Intervals){        if(rightMostStart < curr[0])            rightMostStart = curr[0]        if(leftMostStart > curr[1])            leftMostStart = curr[1]  }   let res;    // if rightmost start > leftmost end then all    // intervals are not aligned and it is not    // possible to cover all of them    if(rightMostStart > leftMostStart)        res = -1             // if x is in between rightmoststart and    // leftmostend then no need to travel any distance    else if(rightMostStart <= x && x <= leftMostStart)        res = 0             // choose minimum according to current position x    else        res = (x < rightMostStart)?rightMostStart-x : x-leftMostStart    return res} // Driver code to test above methodslet Intervals = [[0, 7], [2, 14], [4, 6]]let N = Intervals.lengthlet x = 3 let res = minDistanceToCoverIntervals(Intervals, N, x)if(res == -1)    document.write("Not Possible to cover all intervals","<br>")else    document.write(res) // This code is contributed by shinjanpatra </script>
Output: 
1
Time Complexity: O(N)
Auxiliary Space: O(N)This article is contributed by Utkarsh Trivedi. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above. 
Rajput-Ji
shikhasingrajput
rj13to
surinderdawra388
shinjanpatra
mailaruyashaswi
Geometric
Geometric
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.