Given an array arr[] containing N intervals, the task is to check that if the intervals can be added or subtracted by X after which there are no overlapping intervals. Here X be any real number.
Examples:
Input: arr[] = {[1, 3], [2, 4], [4, 5], [5, 6]}
Output: YES
Explanation:
We can add X = 1000 inand intervals
ans subtract X = 1000 inand intervals. Input: arr[] = {[1, 2], [3, 4], [5, 6]}
Output: YES
Explanation:
No intervals are overlapping.Input: arr[] = {[1, 4], [2, 2], [2, 3]}
Output: NO
Explanation:
There is no possible X such that intervals don’t overlap.
Approach: The idea is to compare each intervals as a pair with the help of the Nested loops and then for each interval check that they overlap. If any three intervals overlap with each other then there is no way to add any value of X to form Non-overlapping.
We can find if there is an overlapping in the three intervals with each other using union find or disjoint set data structures.
Below is the implementation of the above approach:
// C++ implementation to check if the // intervals can be non-overlapping // by adding or subtracting X to // each interval #include <bits/stdc++.h> using namespace std;
// Function to check if two intervals // overlap with each other bool checkOverlapping(vector< int > a,
vector< int > b)
{ if (a[0] < b[0])
{
a.swap(b);
}
// Condition to check if the
// intervals overlap
if (b[0]<= a[0]<= b[1])
return true ;
return false ;
} // Function to check if there // is a existing overlapping // intervals int find( int a[], int i)
{ if (a[i] == i)
return i;
// Path compression
a[i] = find(a, a[i]);
return a[i];
} // Union of two intervals // Returns True // if there is a overlapping // with the same another interval bool Union( int a[], int x, int y)
{ int xs = find(a, x);
int ys = find(a, y);
if (xs == ys)
{
// Both have same
// another
// overlapping interval
return true ;
}
a[ys]= xs;
return false ;
} // Function to check if the intervals // can be added by X to form // non-overlapping intervals bool checkNonOverlapping(vector<vector< int >> arr,
int n)
{ int dsu[n + 1];
for ( int i = 0; i < n + 1; i++)
dsu[i] = i;
for ( int i = 0; i < n; i++)
{
for ( int j = i + 1; j < n; j++)
{
// If the intervals
// overlaps
// we will union them
if (checkOverlapping(arr[i], arr[j]))
{
if (Union(dsu, i, j))
{
return false ;
}
}
}
}
// There is no cycle
return true ;
} // Driver Code int main()
{ vector<vector< int >> arr ={ { 1, 4 },
{ 2, 2 },
{ 2, 3 } };
int n = arr.size();
if (checkNonOverlapping(arr,n))
{
cout << "YES" << endl;
}
else
{
cout << "NO" << endl;
}
return 0;
} // This code is contributed by divyeshrabadiya07 |
// Java implementation to check if the // intervals can be non-overlapping by // by adding or subtracting // X to each interval import java.io.*;
import java.util.*;
class GFG{
// Function to check if two intervals // overlap with each other public static Boolean checkOverlapping(
ArrayList<Integer> a, ArrayList<Integer> b)
{ if (a.get( 0 ) < b.get( 0 ))
{
int temp = a.get( 0 );
a.set( 0 , b.get( 0 ));
b.set( 0 , temp);
temp = a.get( 1 );
a.set( 1 , b.get( 1 ));
b.set( 1 , temp);
}
// Condition to check if the
// intervals overlap
if (b.get( 0 ) <= a.get( 0 ) &&
a.get( 0 ) <= b.get( 1 ))
return true ;
return false ;
} // Function to check if there // is a existing overlapping // intervals public static int find(ArrayList<Integer> a, int i)
{ if (a.get(i) == i)
{
return i;
}
// Path compression
a.set(i,find(a, a.get(i)));
return a.get(i);
} // Union of two intervals Returns True. // If there is a overlapping // with the same another interval public static Boolean union(ArrayList<Integer> a,
int x, int y)
{ int xs = find(a, x);
int ys = find(a, y);
if (xs == ys)
{
// Both have same
// another overlapping
// interval
return true ;
}
a.set(ys, xs);
return false ;
} // Function to check if the intervals // can be added by X to form // non-overlapping intervals public static Boolean checkNonOverlapping(
ArrayList<ArrayList<Integer>> arr, int n)
{ ArrayList<Integer> dsu = new ArrayList<Integer>();
for ( int i = 0 ; i < n + 1 ; i++)
{
dsu.add(i);
}
for ( int i = 0 ; i < n; i++)
{
for ( int j = i + 1 ; j < n; j++)
{
// If the intervals
// overlaps we will
// union them
if (checkOverlapping(arr.get(i),
arr.get(j)))
{
if (union(dsu, i, j))
{
return false ;
}
}
}
}
// There is no cycle
return true ;
} // Driver Code public static void main(String[] args)
{ ArrayList<
ArrayList<Integer>> arr = new ArrayList<
ArrayList<Integer>>();
arr.add( new ArrayList<Integer>(Arrays.asList( 1 , 4 )));
arr.add( new ArrayList<Integer>(Arrays.asList( 2 , 2 )));
arr.add( new ArrayList<Integer>(Arrays.asList( 2 , 3 )));
int n = arr.size();
if (checkNonOverlapping(arr,n))
{
System.out.println( "YES" );
}
else
{
System.out.println( "NO" );
}
} } // This code is contributed by avanitrachhadiya2155 |
# Python3 implementation to check if # the intervals can be non-overlapping by # by adding or subtracting # X to each interval # Function to check if two intervals # overlap with each other def checkOverlapping(a, b):
a, b = max (a, b), min (a, b)
# Condition to check if the
# intervals overlap
if b[ 0 ]< = a[ 0 ]< = b[ 1 ]:
return True
return False
# Function to check if there # is a existing overlapping # intervals def find(a, i):
if a[i] = = i:
return i
# Path compression
a[i] = find(a, a[i])
return a[i]
# Union of two intervals # Returns True # if there is a overlapping # with the same another interval def union(a, x, y):
xs = find(a, x)
ys = find(a, y)
if xs = = ys:
# Both have same
# another
# overlapping interval
return True
a[ys] = xs
return False
# Function to check if the intervals # can be added by X to form # non-overlapping intervals def checkNonOverlapping(arr, n):
dsu = [i for i in range (n + 1 )]
for i in range (n):
for j in range (i + 1 , n):
# If the intervals
# overlaps
# we will union them
if checkOverlapping(arr[i], \
arr[j]):
if union(dsu, i, j):
return False
# There is no cycle
return True
# Driver Code if __name__ = = "__main__" :
arr = [[ 1 , 4 ], [ 2 , 2 ], [ 2 , 3 ]]
n = len (arr)
print ( "YES" if checkNonOverlapping\
(arr, n) else "NO" )
|
// C# implementation to check if // the intervals can be non-overlapping by // by adding or subtracting // X to each interval using System;
using System.Collections.Generic;
class GFG {
// Function to check if two intervals
// overlap with each other
static bool checkOverlapping(List< int > a, List< int > b)
{
if (a[0] < b[0])
{
int temp = a[0];
a[0] = b[0];
b[0] = temp;
temp = a[1];
a[1] = b[1];
b[1] = temp;
}
// Condition to check if the
// intervals overlap
if (b[0] <= a[0] && a[0] <= b[1])
return true ;
return false ;
}
// Function to check if there
// is a existing overlapping
// intervals
static int find(List< int > a, int i)
{
if (a[i] == i)
{
return i;
}
// Path compression
a[i] = find(a, a[i]);
return a[i];
}
// Union of two intervals
// Returns True
// if there is a overlapping
// with the same another interval
static bool union(List< int > a, int x, int y)
{
int xs = find(a, x);
int ys = find(a, y);
if (xs == ys)
{
// Both have same
// another
// overlapping interval
return true ;
}
a[ys] = xs;
return false ;
}
// Function to check if the intervals
// can be added by X to form
// non-overlapping intervals
static bool checkNonOverlapping(List<List< int >> arr, int n)
{
List< int > dsu = new List< int >();
for ( int i = 0; i < n + 1; i++)
{
dsu.Add(i);
}
for ( int i = 0; i < n; i++)
{
for ( int j = i + 1; j < n; j++)
{
// If the intervals
// overlaps
// we will union them
if (checkOverlapping(arr[i], arr[j]))
{
if (union(dsu, i, j))
{
return false ;
}
}
}
}
// There is no cycle
return true ;
}
static void Main() {
List<List< int >> arr = new List<List< int >>();
arr.Add( new List< int > { 1, 4 });
arr.Add( new List< int > { 2, 2 });
arr.Add( new List< int > { 2, 3 });
int n = arr.Count;
if (checkNonOverlapping(arr,n))
{
Console.WriteLine( "YES" );
}
else
{
Console.WriteLine( "NO" );
}
}
} // This code is contributed by divyes072019 |
<script> // JavaScript implementation to check if // the intervals can be non-overlapping by // by adding or subtracting // X to each interval // Function to check if two intervals // overlap with each other function checkOverlapping(a, b)
{ if (a[0] < b[0])
{
var temp = a[0];
a[0] = b[0];
b[0] = temp;
temp = a[1];
a[1] = b[1];
b[1] = temp;
}
// Condition to check if the
// intervals overlap
if (b[0] <= a[0] && a[0] <= b[1])
return true ;
return false ;
} // Function to check if there // is a existing overlapping // intervals function find(a, i)
{ if (a[i] == i)
{
return i;
}
// Path compression
a[i] = find(a, a[i]);
return a[i];
} // Union of two intervals // Returns True // if there is a overlapping // with the same another interval function union(a, x, y)
{ var xs = find(a, x);
var ys = find(a, y);
if (xs == ys)
{
// Both have same
// another
// overlapping interval
return true ;
}
a[ys] = xs;
return false ;
} // Function to check if the intervals // can be added by X to form // non-overlapping intervals function checkNonOverlapping(arr, n)
{ var dsu = [];
for ( var i = 0; i < n + 1; i++)
{
dsu.push(i);
}
for ( var i = 0; i < n; i++)
{
for ( var j = i + 1; j < n; j++)
{
// If the intervals
// overlaps
// we will union them
if (checkOverlapping(arr[i], arr[j]))
{
if (union(dsu, i, j))
{
return false ;
}
}
}
}
// There is no cycle
return true ;
} var arr = Array();
arr.push([1, 4 ]); arr.push([2, 2 ]); arr.push([2, 3 ]); var n = arr.length;
if (checkNonOverlapping(arr,n))
{ document.write( "YES" );
} else { document.write( "NO" );
} </script> |
Output:
NO
Time Complexity: O(n*n*log(n))
Auxiliary Space: O(n),as extra space is used