# Find a pair of overlapping intervals from a given Set

• Difficulty Level : Easy
• Last Updated : 15 Jun, 2021

Given a 2D array arr[][] with each row of the form {l, r}, the task is to find a pair (i, j) such that the ith interval lies within the jth interval. If multiple solutions exist, then print anyone of them. Otherwise, print -1.

Examples:

Input: N = 5, arr[][] = { { 1, 5 }, { 2, 10 }, { 3, 10}, {2, 2}, {2, 15}}
Output: 3 0
Explanation: [2, 2] lies inside [1, 5].

Input: N = 4, arr[][] = { { 2, 10 }, { 1, 9 }, { 1, 8 }, { 1, 7 } }
Output: -1
Explanation: No such pair of intervals exist.

Native Approach: The simplest approach to solve this problem is to generate all possible pairs of the array. For every pair (i, j), check if the ith interval lies within the jth interval or not. If found to be true, then print the pairs. Otherwise, print -1
Time Complexity: O(N2)
Auxiliary Space:O(1)

Efficient Approach: The idea is to sort the segments firstly by their left border in increasing order and in case of equal left borders, sort them by their right borders in decreasing order. Then, just find the intersecting intervals by keeping track of the maximum right border.

Follow the steps below to solve the problem:

1. Sort the given array of intervals according to their left border and if any two left borders are equal, sort them with their right border in decreasing order.
2. Now, traverse from left to right, keep the maximum right border of processed segments and compare it to the current segment.
3. If the segments are overlapping, print their indices.
4. Otherwise, after traversing, if no overlapping segments are found, print -1.

Below is the implementation of the above approach:

## C++

 `// C++ program to implement``// the above approach``#include ``using` `namespace` `std;` `// Function to find a pair(i, j) such that``// i-th interval lies within the j-th interval``void` `findOverlapSegement(``int` `N, ``int` `a[], ``int` `b[])``{` `    ``// Store interval and index of the interval``    ``// in the form of { {l, r}, index }``    ``vector, ``int``> > tup;` `    ``// Traverse the array, arr[][]``    ``for` `(``int` `i = 0; i < N; i++) {` `        ``int` `x, y;` `        ``// Stores l-value of``        ``// the interval``        ``x = a[i];` `        ``// Stores r-value of``        ``// the interval``        ``y = b[i];` `        ``// Push current interval and index into tup``        ``tup.push_back(pair, ``int``>(``            ``pair<``int``, ``int``>(x, y), i));``    ``}` `    ``// Sort the vector based on l-value``    ``// of the intervals``    ``sort(tup.begin(), tup.end());` `    ``// Stores r-value of current interval``    ``int` `curr = tup[0].first.second;` `    ``// Stores index of current interval``    ``int` `currPos = tup[0].second;` `    ``// Traverse the vector, tup[]``    ``for` `(``int` `i = 1; i < N; i++) {` `        ``// Stores l-value of previous interval``        ``int` `Q = tup[i - 1].first.first;` `        ``// Stores l-value of current interval``        ``int` `R = tup[i].first.first;` `        ``// If Q and R are equal``        ``if` `(Q == R) {` `            ``// Print the index of interval``            ``if` `(tup[i - 1].first.second``                ``< tup[i].first.second)``                ``cout << tup[i - 1].second << ``' '``                     ``<< tup[i].second;` `            ``else``                ``cout << tup[i].second << ``' '``                     ``<< tup[i - 1].second;` `            ``return``;``        ``}` `        ``// Stores r-value of current interval``        ``int` `T = tup[i].first.second;` `        ``// If T is less than or equal to curr``        ``if` `(T <= curr) {``            ``cout << tup[i].second << ``' '` `<< currPos;``            ``return``;``        ``}``        ``else` `{` `            ``// Update curr``            ``curr = T;` `            ``// Update currPos``            ``currPos = tup[i].second;``        ``}``    ``}` `    ``// If such intervals found``    ``cout << ``"-1 -1"``;``}` `// Driver Code``int` `main()``{` `    ``// Given l-value of segments``    ``int` `a[] = { 1, 2, 3, 2, 2 };` `    ``// Given r-value of segments``    ``int` `b[] = { 5, 10, 10, 2, 15 };` `    ``// Given size``    ``int` `N = ``sizeof``(a) / ``sizeof``(``int``);` `    ``// Function Call``    ``findOverlapSegement(N, a, b);``}`

## Java

 `// Java program to implement``// the above approach``import` `java.util.*;``import` `java.lang.*;` `class` `pair{``  ``int` `l,r,index;` `  ``pair(``int` `l, ``int` `r, ``int` `index){``    ``this``.l = l;``    ``this``.r = r;``    ``this``.index=index;``  ``}``}``class` `GFG {` `  ``// Function to find a pair(i, j) such that``  ``// i-th interval lies within the j-th interval``  ``static` `void` `findOverlapSegement(``int` `N, ``int``[] a, ``int``[] b)``  ``{` `    ``// Store interval and index of the interval``    ``// in the form of { {l, r}, index }``    ``ArrayList tup = ``new` `ArrayList<>();` `    ``// Traverse the array, arr[][]``    ``for` `(``int` `i = ``0``; i < N; i++) {` `      ``int` `x, y;` `      ``// Stores l-value of``      ``// the interval``      ``x = a[i];` `      ``// Stores r-value of``      ``// the interval``      ``y = b[i];` `      ``// Push current interval and index into tup``      ``tup.add(``new` `pair(x, y, i));``    ``}` `    ``// Sort the vector based on l-value``    ``// of the intervals``    ``Collections.sort(tup,(aa,bb)->(aa.l!=bb.l)?aa.l-bb.l:aa.r-bb.r);` `    ``// Stores r-value of current interval``    ``int` `curr = tup.get(``0``).r;` `    ``// Stores index of current interval``    ``int` `currPos = tup.get(``0``).index;` `    ``// Traverse the vector, tup[]``    ``for` `(``int` `i = ``1``; i < N; i++) {` `      ``// Stores l-value of previous interval``      ``int` `Q = tup.get(i - ``1``).l;` `      ``// Stores l-value of current interval``      ``int` `R = tup.get(i).l;` `      ``// If Q and R are equal``      ``if` `(Q == R) {` `        ``// Print the index of interval``        ``if` `(tup.get(i - ``1``).r < tup.get(i).r)``          ``System.out.print(tup.get(i - ``1``).index + ``" "` `+ tup.get(i).index);` `        ``else``          ``System.out.print(tup.get(i).index + ``" "` `+ tup.get(i - ``1``).index);` `        ``return``;``      ``}` `      ``// Stores r-value of current interval``      ``int` `T = tup.get(i).r;` `      ``// If T is less than or equal to curr``      ``if` `(T <= curr) {``        ``System.out.print(tup.get(i).index + ``" "` `+ currPos);``        ``return``;``      ``}``      ``else` `{` `        ``// Update curr``        ``curr = T;` `        ``// Update currPos``        ``currPos = tup.get(i).index;``      ``}``    ``}` `    ``// If such intervals found``    ``System.out.print(``"-1 -1"``);``  ``}    ` `  ``// Driver code``  ``public` `static` `void` `main (String[] args)``  ``{` `    ``// Given l-value of segments``    ``int``[] a = { ``1``, ``2``, ``3``, ``2``, ``2` `};` `    ``// Given r-value of segments``    ``int``[] b = { ``5``, ``10``, ``10``, ``2``, ``15` `};` `    ``// Given size``    ``int` `N = a.length;` `    ``// Function Call``    ``findOverlapSegement(N, a, b);``  ``}``}` `// This code is contributed by offbeat.`

## Python3

 `# Python3 program to implement``# the above approach` `# Function to find a pair(i, j) such that``# i-th interval lies within the j-th interval``def` `findOverlapSegement(N, a, b) :``    ` `    ``# Store interval and index of the interval``    ``# in the form of { {l, r}, index }``    ``tup ``=` `[]``    ` `    ``# Traverse the array, arr[][]``    ``for` `i ``in` `range``(N) :``        ` `        ``# Stores l-value of``        ``# the interval``        ``x ``=` `a[i]``        ` `        ``# Stores r-value of``        ``# the interval``        ``y ``=` `b[i]``        ` `        ``# Push current interval and index into tup``        ``tup.append(((x,y),i))``        ` `    ``# Sort the vector based on l-value``    ``# of the intervals``    ``tup.sort()``    ` `    ``# Stores r-value of current interval``    ``curr ``=` `tup[``0``][``0``][``1``]``    ` `    ``# Stores index of current interval``    ``currPos ``=` `tup[``0``][``1``]``    ` `    ``# Traverse the vector, tup[]``    ``for` `i ``in` `range``(``1``,N) :``        ` `        ``# Stores l-value of previous interval``        ``Q ``=` `tup[i ``-` `1``][``0``][``0``]``        ` `        ``# Stores l-value of current interval``        ``R ``=` `tup[i][``0``][``0``]``        ` `        ``# If Q and R are equal``        ``if` `Q ``=``=` `R :``            ` `            ``# Print the index of interval``            ``if` `tup[i ``-` `1``][``0``][``1``] < tup[i][``0``][``1``] :``                ` `                ``print``(tup[i ``-` `1``][``1``], tup[i][``1``])``                ` `            ``else` `:``                ` `                ``print``(tup[i][``1``], tup[i ``-` `1``][``1``])``                ` `            ``return``        ` `        ``# Stores r-value of current interval``        ``T ``=` `tup[i][``0``][``1``]``        ` `        ``# If T is less than or equal to curr``        ``if` `(T <``=` `curr) :``            ` `            ``print``(tup[i][``1``], currPos)``            ` `            ``return``        ``else` `:``            ` `            ``# Update curr``            ``curr ``=` `T``            ` `            ``# Update currPos``            ``currPos ``=` `tup[i][``1``]``            ` `    ``# If such intervals found``    ``print``(``"-1"``, ``"-1"``, end ``=` `"")``    ` `# Given l-value of segments``a ``=` `[ ``1``, ``2``, ``3``, ``2``, ``2` `]` `# Given r-value of segments``b ``=` `[ ``5``, ``10``, ``10``, ``2``, ``15` `]` `# Given size``N ``=` `len``(a)` `# Function Call``findOverlapSegement(N, a, b)` `# This code is contributed by divyesh072019`

## C#

 `// C# program to implement``// the above approach``using` `System;``using` `System.Collections.Generic;``class` `GFG {` `  ``// Function to find a pair(i, j) such that``  ``// i-th interval lies within the j-th interval``  ``static` `void` `findOverlapSegement(``int` `N, ``int``[] a, ``int``[] b)``  ``{` `    ``// Store interval and index of the interval``    ``// in the form of { {l, r}, index }``    ``List, ``int``>> tup = ``new` `List, ``int``>>();` `    ``// Traverse the array, arr[][]``    ``for` `(``int` `i = 0; i < N; i++) {` `      ``int` `x, y;` `      ``// Stores l-value of``      ``// the interval``      ``x = a[i];` `      ``// Stores r-value of``      ``// the interval``      ``y = b[i];` `      ``// Push current interval and index into tup``      ``tup.Add(``new` `Tuple, ``int``>(``new` `Tuple<``int``, ``int``>(x, y), i));``    ``}` `    ``// Sort the vector based on l-value``    ``// of the intervals``    ``tup.Sort();` `    ``// Stores r-value of current interval``    ``int` `curr = tup[0].Item1.Item2;` `    ``// Stores index of current interval``    ``int` `currPos = tup[0].Item2;` `    ``// Traverse the vector, tup[]``    ``for` `(``int` `i = 1; i < N; i++) {` `      ``// Stores l-value of previous interval``      ``int` `Q = tup[i - 1].Item1.Item1;` `      ``// Stores l-value of current interval``      ``int` `R = tup[i].Item1.Item1;` `      ``// If Q and R are equal``      ``if` `(Q == R) {` `        ``// Print the index of interval``        ``if` `(tup[i - 1].Item1.Item2 < tup[i].Item1.Item2)``          ``Console.Write(tup[i - 1].Item2 + ``" "` `+ tup[i].Item2);` `        ``else``          ``Console.Write(tup[i].Item2 + ``" "` `+ tup[i - 1].Item2);` `        ``return``;``      ``}` `      ``// Stores r-value of current interval``      ``int` `T = tup[i].Item1.Item2;` `      ``// If T is less than or equal to curr``      ``if` `(T <= curr) {``        ``Console.Write(tup[i].Item2 + ``" "` `+ currPos);``        ``return``;``      ``}``      ``else` `{` `        ``// Update curr``        ``curr = T;` `        ``// Update currPos``        ``currPos = tup[i].Item2;``      ``}``    ``}` `    ``// If such intervals found``    ``Console.Write(``"-1 -1"``);``  ``}    ` `  ``// Driver code``  ``static` `void` `Main()``  ``{` `    ``// Given l-value of segments``    ``int``[] a = { 1, 2, 3, 2, 2 };` `    ``// Given r-value of segments``    ``int``[] b = { 5, 10, 10, 2, 15 };` `    ``// Given size``    ``int` `N = a.Length;` `    ``// Function Call``    ``findOverlapSegement(N, a, b);``  ``}``}` `// This code is contributed by divyeshrabadiya07`

## Javascript

 ``

Output:

`3 0`

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

My Personal Notes arrow_drop_up