Skip to content
Related Articles
Check if any K ranges overlap at any point
• Last Updated : 10 Jun, 2021

Given N ranges [L, R] and an integer K, the task is to check if there are any K ranges which overlap at any point.

Examples:

Input: ranges[][] = {{1, 3}, {2, 4}, {3, 4}, {7, 10}}, K = 3
Output: Yes
3 is a common point among the
ranges {1, 3}, {2, 4} and {3, 4}.

Input: ranges[][] = {{1, 2}, {3, 4}, {5, 6}, {7, 8}}, K = 2
Output: No

Approach: The idea is to make a vector of pair and store the starting point for every range as pair in this vector as (starting point, -1) and the ending point as (ending point, 1). Now, sort the vector then traverse the vector and if the current element is a starting point then push it in a stack and if it is an ending point then pop an element from the stack. If at any instance of time, the size of the stack is greater than or equal K then print Yes else print No in the end.

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach``#include ``using` `namespace` `std;` `// Comparator to sort the vector of pairs``bool` `sortby(``const` `pair<``int``, ``int``>& a,``            ``const` `pair<``int``, ``int``>& b)``{``    ``if` `(a.first != b.first)``        ``return` `a.first < b.first;``    ``return` `(a.second < b.second);``}` `// Function that returns true if any k``// segments overlap at any point``bool` `kOverlap(vector > pairs, ``int` `k)``{``    ``// Vector to store the starting point``    ``// and the ending point``    ``vector > vec;``    ``for` `(``int` `i = 0; i < pairs.size(); i++) {` `        ``// Starting points are marked by -1``        ``// and ending points by +1``        ``vec.push_back({ pairs[i].first, -1 });``        ``vec.push_back({ pairs[i].second, +1 });``    ``}` `    ``// Sort the vector by first element``    ``sort(vec.begin(), vec.end());` `    ``// Stack to store the overlaps``    ``stack > st;` `    ``for` `(``int` `i = 0; i < vec.size(); i++) {``        ``// Get the current element``        ``pair<``int``, ``int``> cur = vec[i];` `        ``// If it is the starting point``        ``if` `(cur.second == -1) {``            ``// Push it in the stack``            ``st.push(cur);``        ``}` `        ``// It is the ending point``        ``else` `{``            ``// Pop an element from stack``            ``st.pop();``        ``}` `        ``// If more than k ranges overlap``        ``if` `(st.size() >= k) {``            ``return` `true``;``        ``}``    ``}` `    ``return` `false``;``}` `// Driver code``int` `main()``{``    ``vector > pairs;``    ``pairs.push_back(make_pair(1, 3));``    ``pairs.push_back(make_pair(2, 4));``    ``pairs.push_back(make_pair(3, 5));``    ``pairs.push_back(make_pair(7, 10));` `    ``int` `n = pairs.size(), k = 3;` `    ``if` `(kOverlap(pairs, k))``        ``cout << ``"Yes"``;``    ``else``        ``cout << ``"No"``;` `    ``return` `0;``}`

## Java

 `// Java implementation of the approach``import` `java.util.ArrayList;``import` `java.util.Collections;``import` `java.util.Comparator;``import` `java.util.Stack;` `class` `GFG{` `static` `class` `Pair``{``    ``int` `first, second;` `    ``public` `Pair(``int` `first, ``int` `second)``    ``{``        ``this``.first = first;``        ``this``.second = second;``    ``}``}` `// Function that returns true if any k``// segments overlap at any point``static` `boolean` `kOverlap(ArrayList pairs,``                        ``int` `k)``{``    ` `    ``// Vector to store the starting point``    ``// and the ending point``    ``ArrayList vec = ``new` `ArrayList<>();``    ``for``(``int` `i = ``0``; i < pairs.size(); i++)``    ``{``        ` `        ``// Starting points are marked by -1``        ``// and ending points by +1``        ``vec.add(``new` `Pair(pairs.get(i).first, -``1``));``        ``vec.add(``new` `Pair(pairs.get(i).second, +``1``));``    ``}``    ` `    ``// Sort the vector by first element``    ``Collections.sort(vec, ``new` `Comparator()``    ``{``        ` `        ``// Comparator to sort the vector of pairs``        ``public` `int` `compare(Pair a, Pair b)``        ``{``            ``if` `(a.first != b.first)``                ``return` `a.first - b.first;``                ` `            ``return` `(a.second - b.second);``        ``}``    ``});` `    ``// Stack to store the overlaps``    ``Stack st = ``new` `Stack<>();` `    ``for``(``int` `i = ``0``; i < vec.size(); i++)``    ``{``        ` `        ``// Get the current element``        ``Pair cur = vec.get(i);` `        ``// If it is the starting point``        ``if` `(cur.second == -``1``)``        ``{``            ` `            ``// Push it in the stack``            ``st.push(cur);``        ``}` `        ``// It is the ending point``        ``else``        ``{``            ` `            ``// Pop an element from stack``            ``st.pop();``        ``}` `        ``// If more than k ranges overlap``        ``if` `(st.size() >= k)``        ``{``            ``return` `true``;``        ``}``    ``}``    ``return` `false``;``}` `// Driver code``public` `static` `void` `main(String[] args)``{``    ``ArrayList pairs = ``new` `ArrayList<>();``    ``pairs.add(``new` `Pair(``1``, ``3``));``    ``pairs.add(``new` `Pair(``2``, ``4``));``    ``pairs.add(``new` `Pair(``3``, ``5``));``    ``pairs.add(``new` `Pair(``7``, ``10``));` `    ``int` `n = pairs.size(), k = ``3``;` `    ``if` `(kOverlap(pairs, k))``        ``System.out.println(``"Yes"``);``    ``else``        ``System.out.println(``"No"``);``}``}` `// This code is contributed by sanjeev2552`

## Python3

 `# Python3 implementation of the approach` `# Function that returns true if any k``# segments overlap at any point``def` `kOverlap(pairs: ``list``, k):` `    ``# Vector to store the starting point``    ``# and the ending point``    ``vec ``=` `list``()``    ``for` `i ``in` `range``(``len``(pairs)):` `        ``# Starting points are marked by -1``        ``# and ending points by +1``        ``vec.append((pairs[``0``], ``-``1``))``        ``vec.append((pairs[``1``], ``1``))` `    ``# Sort the vector by first element``    ``vec.sort(key ``=` `lambda` `a: a[``0``])` `    ``# Stack to store the overlaps``    ``st ``=` `list``()` `    ``for` `i ``in` `range``(``len``(vec)):` `        ``# Get the current element``        ``cur ``=` `vec[i]` `        ``# If it is the starting point``        ``if` `cur[``1``] ``=``=` `-``1``:` `            ``# Push it in the stack``            ``st.append(cur)` `        ``# It is the ending point``        ``else``:` `            ``# Pop an element from stack``            ``st.pop()` `        ``# If more than k ranges overlap``        ``if` `len``(st) >``=` `k:``            ``return` `True``    ``return` `False`  `# Driver Code``if` `__name__ ``=``=` `"__main__"``:``    ``pairs ``=` `list``()``    ``pairs.append((``1``, ``3``))``    ``pairs.append((``2``, ``4``))``    ``pairs.append((``3``, ``5``))``    ``pairs.append((``7``, ``10``))` `    ``n ``=` `len``(pairs)``    ``k ``=` `3` `    ``if` `kOverlap(pairs, k):``        ``print``(``"Yes"``)``    ``else``:``        ``print``(``"No"``)` `# This code is contributed by``# sanjeev2552`

## C#

 `// C# implementation of the approach``using` `System;``using` `System.Collections;``using` `System.Collections.Generic;``class` `GFG``{` `// Function that returns true if any k``// segments overlap at any point``static` `bool` `kOverlap(List> pairs,``                        ``int` `k)``{``    ` `    ``// Vector to store the starting point``    ``// and the ending point``    ``List> vec = ``new` `List>();``    ``for``(``int` `i = 0; i < pairs.Count; i++)``    ``{``        ` `        ``// Starting points are marked by -1``        ``// and ending points by +1``        ``vec.Add(``new` `Tuple<``int``,``int``>(pairs[i].Item1,-1));``        ``vec.Add(``new` `Tuple<``int``,``int``>(pairs[i].Item2,1));``    ``}``    ``vec.Sort();` `    ``// Stack to store the overlaps``    ``Stack st = ``new` `Stack();``    ``for``(``int` `i = 0; i < vec.Count; i++)``    ``{``        ` `        ``// Get the current element``        ``Tuple<``int``,``int``> cur = vec[i];` `        ``// If it is the starting point``        ``if` `(cur.Item2 == -1)``        ``{``            ` `            ``// Push it in the stack``            ``st.Push(cur);``        ``}` `        ``// It is the ending point``        ``else``        ``{``            ` `            ``// Pop an element from stack``            ``st.Pop();``        ``}` `        ``// If more than k ranges overlap``        ``if` `(st.Count >= k)``        ``{``            ``return` `true``;``        ``}``    ``}``    ``return` `false``;``}` `// Driver code``public` `static` `void` `Main(``params` `string``[] args)``{``    ``List> pairs = ``new` `List>();``    ``pairs.Add(``new` `Tuple<``int``,``int``>(1, 3));``    ``pairs.Add(``new` `Tuple<``int``,``int``>(2, 4));``    ``pairs.Add(``new` `Tuple<``int``,``int``>(3, 5));``    ``pairs.Add(``new` `Tuple<``int``,``int``>(7, 10));` `    ``int` `n = pairs.Count, k = 3;``    ``if` `(kOverlap(pairs, k))``        ``Console.WriteLine(``"Yes"``);``    ``else``        ``Console.WriteLine(``"No"``);``}``}` `// This code is contributed by rutvik_56/`

## Javascript

 ``
Output:
`Yes`

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with industry experts, please refer DSA Live Classes

My Personal Notes arrow_drop_up