给定大小为N的2D数组arr [] [] ，每行代表格式为{X，Y}的间隔(基于1的索引)，这是查找一对重叠间隔的索引的任务。如果不存在这样的对，则打印-1 -1 。
例子：
Input: N = 5, arr[][] = {{1, 5}, {2, 10}, {3, 10}, {2, 2}, {2, 15}}
Output: 4 1
Explanation: The range at position 4 i.e., (2, 2) lies inside the range at position 1 i.e., (1, 5).
Input: N = 4, arr[][] = {{2, 10}, {1, 9}, {1, 8}, {1, 7}}
Output: -1 -1
幼稚的方法：最简单的方法是检查每对间隔，如果它们中的一个位于另一个之中或不在另一个之中。如果没有找到这样的间隔，则打印-1 -1 ，否则，打印找到的间隔的索引。
时间复杂度： O(N 2 )其中N是给定的整数。
辅助空间： O(N)
高效方法：想法是根据每个间隔的左侧部分对给定的间隔集进行排序。请按照以下步骤解决问题：
- 首先，通过存储每个间隔的索引，按片段的左边界以升序对片段进行排序。
- 然后，使用排序数组中第一个间隔的左部分及其索引分别初始化变量curr和currPos 。
- 现在，遍历从i = 0到N – 1的排序间隔。
- 如果任意两个相邻间隔的左部分相等，则打印它们的索引，因为其中一个必须位于另一个内部。
- 如果当前间隔的右侧部分大于curr ，则将curr设置为该右侧部分，并将currPos设置为该间隔在原始数组中的索引。否则，打印当前间隔的索引以及存储在currPos变量中的索引。
- 遍历后，如果找不到这样的间隔，则打印-1 -1 。
下面是上述方法的实现：
C++
// C++ program for the above approach
#include
using namespace std;
// Pair of two integers
// of the form {X, Y}
typedef pair ii;
// Pair of pairs and integers
typedef pair iii;
// FUnction to find a pair of indices of
// the overlapping interval in the array
ii segment_overlapping(int N,
vector > arr)
{
// Store intervals {X, Y} along
// with their indices
vector tup;
// Traverse the given intervals
for (int i = 0; i < N; i++) {
int x, y;
x = arr[i][0];
y = arr[i][1];
// Store intervals and their indices
tup.push_back(iii(ii(x, y), i + 1));
}
// Sort the intervals
sort(tup.begin(), tup.end());
// Stores Y of the first interval
int curr = tup[0].first.second;
// Stores index of first interval
int currPos = tup[0].second;
// Traverse the sorted intervals
for (int i = 1; i < N; i++) {
// Stores X value of previous interval
int Q = tup[i - 1].first.first;
// Stores X value of current interval
int R = tup[i].first.first;
// If Q and R equal
if (Q == R) {
// If Y value of immediate previous
// interval is less than Y value of
// current interval
if (tup[i - 1].first.second
< tup[i].first.second) {
// Stores index of immediate
// previous interval
int X = tup[i - 1].second;
// Stores index of current
// interval
int Y = tup[i].second;
return { X, Y };
}
else {
// Stores index of current
// interval
int X = tup[i].second;
// Stores index of immediate
// previous interval
int Y = tup[i - 1].second;
return { X, Y };
}
}
// Stores Y value of current interval
int T = tup[i].first.second;
// T is less than or equal to curr
if (T <= curr)
return { tup[i].second, currPos };
else {
// Update curr
curr = T;
// Update currPos
currPos = tup[i].second;
}
}
// No answer exists
return { -1, -1 };
}
// Driver Code
int main()
{
// Given intervals
vector > arr = { { 1, 5 }, { 2, 10 },
{ 3, 10 }, { 2, 2 },
{ 2, 15 } };
// Size of intervals
int N = arr.size();
// Find answer
ii ans = segment_overlapping(N, arr);
// Print answer
cout << ans.first << " " << ans.second;
} Java
// Java program for above approach
import java.util.*;
import java.lang.*;
// Pair of two integers
// of the form {X, Y}
class pair1
{
int first, second;
pair1(int first, int second)
{
this.first = first;
this.second = second;
}
}
// Pair of pairs and integers
class pair2
{
int first, second, index;
pair2(int first, int second, int index)
{
this.first = first;
this.second = second;
this.index = index;
}
}
class GFG
{
// Function to find a pair of indices of
// the overlapping interval in the array
static pair1 segment_overlapping(int N,
int[][] arr)
{
// Store intervals {X, Y} along
// with their indices
ArrayList tup=new ArrayList<>();
// Traverse the given intervals
for (int i = 0; i < N; i++)
{
int x, y;
x = arr[i][0];
y = arr[i][1];
// Store intervals and their indices
tup.add(new pair2(x, y, i + 1));
}
// Sort the intervals
Collections.sort(tup, (a, b)->(a.first != b.first) ?
a.first - b.first:a.second - b.second);
// Stores Y of the first interval
int curr = tup.get(0).second;
// Stores index of first interval
int currPos = tup.get(0).index;
// Traverse the sorted intervals
for (int i = 1; i < N; i++)
{
// Stores X value of previous interval
int Q = tup.get(i - 1).first;
// Stores X value of current interval
int R = tup.get(i).first;
// If Q and R equal
if (Q == R)
{
// If Y value of immediate previous
// interval is less than Y value of
// current interval
if (tup.get(i - 1).second
< tup.get(i).second)
{
// Stores index of immediate
// previous interval
int X = tup.get(i - 1).index;
// Stores index of current
// interval
int Y = tup.get(i).index;
return new pair1( X, Y );
}
else {
// Stores index of current
// interval
int X = tup.get(i).index;
// Stores index of immediate
// previous interval
int Y = tup.get(i - 1).index;
return new pair1( X, Y );
}
}
// Stores Y value of current interval
int T = tup.get(i).second;
// T is less than or equal to curr
if (T <= curr)
return new pair1( tup.get(i).index, currPos );
else
{
// Update curr
curr = T;
// Update currPos
currPos = tup.get(i).index;
}
}
// No answer exists
return new pair1(-1, -1 );
}
// Driver function
public static void main (String[] args)
{
// Given intervals
int[][] arr = { { 1, 5 }, { 2, 10 },
{ 3, 10 }, { 2, 2 },
{ 2, 15 } };
// Size of intervals
int N = arr.length;
// Find answer
pair1 ans = segment_overlapping(N, arr);
// Print answer
System.out.print(ans.first+" "+ans.second);
}
}
// This code is contributed by offbeat Python3
# Python3 program for the above approach
# FUnction to find a pair of indices of
# the overlapping interval in the array
def segment_overlapping(N, arr):
# Store intervals {X, Y} along
# with their indices
tup = []
# Traverse the given intervals
for i in range(N):
x = arr[i][0]
y = arr[i][1]
# Store intervals and their indices
tup.append([x, y, i + 1])
# Sort the intervals
tup = sorted(tup)
# Stores Y of the first interval
curr = tup[0][1]
# Stores index of first interval
currPos = tup[0][2]
# Traverse the sorted intervals
for i in range(1, N):
# Stores X value of previous interval
Q = tup[i - 1][0]
# Stores X value of current interval
R = tup[i][0]
# If Q and R equal
if (Q == R):
# If Y value of immediate previous
# interval is less than Y value of
# current interval
if (tup[i - 1][1] < tup[i][1]):
# Stores index of immediate
# previous interval
X = tup[i - 1][2]
# Stores index of current
# interval
Y = tup[i][2]
return [X, Y]
else:
# Stores index of current
# interval
X = tup[i][2]
# Stores index of immediate
# previous interval
Y = tup[i - 1][2]
return { X, Y }
# Stores Y value of current interval
T = tup[i][1]
# T is less than or equal to curr
if (T <= curr):
return [tup[i][2], currPos]
else:
# Update curr
curr = T
# Update currPos
currPos = tup[i][2]
# No answer exists
return [ -1, -1 ]
# Driver Code
if __name__ == '__main__':
# Given intervals
arr = [ [ 1, 5 ], [ 2, 10 ], [ 3, 10 ], [ 2, 2 ], [2, 15 ] ]
# Size of intervals
N = len(arr)
# Find answer
ans = segment_overlapping(N, arr)
# Pranswer
print(ans[0], ans[1])
# This code is contributed by mohit kumar 29输出：
4 1时间复杂度： O(N * log(N))
辅助空间： O(N)