给定一个二维数组arr [] [] ，每行的格式为{l，r} ，任务是找到一个对(i，j) ，使第i个间隔位于第j个间隔内。如果存在多个解决方案，请打印其中的任何一个。否则，打印-1 。
例子：
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.
本机方法：解决此问题的最简单方法是生成所有可能的数组对。对于每对(i，j) ，检查第i个间隔是否在第j个间隔内。如果发现是正确的，则打印对。否则，打印-1 。
时间复杂度： O(N 2 )
辅助空间： O(1)
高效的方法：想法是首先按分段的左边界以升序对它们进行排序，在相等的左边界的情况下，按其右边界以降序对它们进行排序。然后，只需跟踪最大右边界即可找到相交的间隔。
请按照以下步骤解决问题：
- 根据它们的左边界对给定的间隔数组进行排序，如果两个左边界相等，则按其右边界递减的顺序对其进行排序。
- 现在，从左向右遍历，保留已处理段的最大右边界并将其与当前段进行比较。
- 如果段重叠，则打印其索引。
- 否则，在遍历之后，如果找不到重叠的段，则打印-1 。
下面是上述方法的实现：
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(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 divyesh072019C#
// 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(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 输出：
3 0时间复杂度： O(N * log(N))
辅助空间： O(N)