对具有位于其最小值和最大值之间的所有其他给定对

给定一个由N对整数组成的二维数组arr[][] ，任务是找到覆盖给定数组的所有其他对的对。如果不可能找到这样的一对，则打印-1 。

A pair {a,  b} will cover another pair {c,  d}, if the condition (a ≤ c ≤ d ≤ b) holds true. 

例子：

Input: arr[][2] = {{2, 2}, {3, 3}, {3, 5}, {4, 5}, {1, 1}, {1, 5}}
Output: 6
Explanation:
There exist a pair (1, 5) which cover all other pair because all other pair lies in the pair {1, 5}.
Therefore, the position of the pair {1, 5} is 6. So, the output is 6.

Input: arr[][] = {{1, 20}, {2, 22}, {3, 18}}
Output: -1
Explanation:
No such pair exists which covers all the remaining pairs.
Therefore, the output is -1 

朴素的方法：最简单的方法是将每对与所有其他对进行比较，并检查是否有任何对覆盖所有对。以下是步骤：

1. 初始化一个变量count = 0 ，它存储位于当前对之间的对数。
2. 遍历对数组，对于每一对，检查计数是否等于对的总数。
3. 如果发现为真，则表示该对可以覆盖所有其他对。打印这对。
4. 否则，设置count = 0并为下一对重复上述步骤。
5. 如果不存在这样的对，则打印-1 。

下面是上述方法的实现：

C++

// C++ program for the above approach
 
#include 
using namespace std;
 
// Function to find the position of
// the pair that covers every pair
// in the array arr[][]
void position(int arr[][2], int N)
{
    // Stores the index of the
    // resultant pair
    int pos = -1;
 
    // To count the occurences
    int count;
 
    // Iterate to check every pair
    for (int i = 0; i < N; i++) {
 
        // Set count to 0
        count = 0;
 
        for (int j = 0; j < N; j++) {
 
            // Condition to checked for
            // overlapping of pairs
            if (arr[i][0] <= arr[j][0]
                && arr[i][1] >= arr[j][1]) {
                count++;
            }
        }
 
        // If that pair can cover all other
        // pairs then store its position
        if (count == N) {
            pos = i;
        }
    }
 
    // If position not found
    if (pos == -1) {
 
        cout << pos;
    }
 
    // Otherwise
    else {
 
        cout << pos + 1;
    }
}
 
// Driver Code
int main()
{
    // Given array of pairs
    int arr[][2] = {{ 3, 3 }, { 1, 3 },
                    { 2, 2 }, { 2, 3 },
                    { 1, 2 }};
 
    int N = sizeof(arr) / sizeof(arr[0]);
 
    // Function Call
    position(arr, N);
}

Java

// Java program for
// the above approach
import java.util.*;
class GFG{
 
// Function to find the position of
// the pair that covers every pair
// in the array arr[][]
static void position(int arr[][],
                     int N)
{
  // Stores the index of the
  // resultant pair
  int pos = -1;
 
  // To count the occurences
  int count;
 
  // Iterate to check every pair
  for (int i = 0; i < N; i++)
  {
    // Set count to 0
    count = 0;
 
    for (int j = 0; j < N; j++)
    {
      // Condition to checked for
      // overlapping of pairs
      if (arr[i][0] <= arr[j][0] &&
          arr[i][1] >= arr[j][1])
      {
        count++;
      }
    }
 
    // If that pair can cover all other
    // pairs then store its position
    if (count == N)
    {
      pos = i;
    }
  }
 
  // If position not found
  if (pos == -1)
  {
    System.out.print(pos);
  }
 
  // Otherwise
  else
  {
    System.out.print(pos + 1);
  }
}
 
// Driver Code
public static void main(String[] args)
{
  // Given array of pairs
  int arr[][] = {{3, 3}, {1, 3},
                 {2, 2}, {2, 3},
                 {1, 2}};
 
  int N = arr.length;
 
  // Function Call
  position(arr, N);
}
}
 
// This code is contributed by 29AjayKumar

Python3

# Python3 program for
# the above approach
 
# Function to find the position of
# the pair that covers every pair
# in the array arr
def position(arr, N):
   
    # Stores the index of the
    # resultant pair
    pos = -1;
 
    # To count the occurences
    count = 0;
 
    # Iterate to check every pair
    for i in range(N):
       
        # Set count to 0
        count = 0;
 
        for j in range(N):
            # Condition to checked for
            # overlapping of pairs
            if (arr[i][0] <= arr[j][0] and
                arr[i][1] >= arr[j][1]):
                count += 1;
 
        # If that pair can cover
        # all other pairs then
        # store its position
        if (count == N):
            pos = i;
 
    # If position not found
    if (pos == -1):
        print(pos);
 
    # Otherwise
    else:
        print(pos + 1);
 
# Driver Code
if __name__ == '__main__':
   
    # Given array of pairs
    arr = [[3, 3], [1, 3],
           [2, 2], [2, 3],
           [1, 2]];
 
    N = len(arr);
 
    # Function Call
    position(arr, N);
 
# This code is contributed by shikhasingrajput

C#

// C# program for
// the above approach
using System;
class GFG{
  
// Function to find the position of
// the pair that covers every pair
// in the array arr[][]
static void position(int[,] arr,
                     int N)
{
  // Stores the index of the
  // resultant pair
  int pos = -1;
 
  // To count the occurences
  int count;
 
  // Iterate to check every pair
  for(int i = 0; i < N; i++)
  {
    // Set count to 0
    count = 0;
 
    for(int j = 0; j < N; j++)
    {
      // Condition to checked for
      // overlapping of pairs
      if (arr[i, 0] <= arr[j, 0] &&
          arr[i, 1] >= arr[j, 1])
      {
        count++;
      }
    }
 
    // If that pair can cover
    // all other pairs then
    // store its position
    if (count == N)
    {
      pos = i;
    }
  }
 
  // If position not found
  if (pos == -1)
  {
    Console.Write(pos);
  }
 
  // Otherwise
  else
  {
    Console.Write(pos + 1);
  }
}
 
// Driver Code
public static void Main()
{ 
  // Give array of pairs
  int[,] arr = {{3, 3}, {1, 3},
                {2, 2}, {2, 3},
                {1, 2}};
 
  int N = arr.GetLength(0);
 
  // Function Call
  position(arr, N);
}
}
 
// This code is contributed by sanjoy_62

Javascript

 
// Javascript program for
// the above approach
 
// Function to find the position of
// the pair that covers every pair
// in the array arr[][]
function position(arr, N)
{
  // Stores the index of the
  // resultant pair
  let pos = -1;
  
  // To count the occurences
  let count;
  
  // Iterate to check every pair
  for (let i = 0; i < N; i++)
  {
    // Set count to 0
    count = 0;
  
    for (let j = 0; j < N; j++)
    {
      // Condition to checked for
      // overlapping of pairs
      if (arr[i][0] <= arr[j][0] &&
          arr[i][1] >= arr[j][1])
      {
        count++;
      }
    }
  
    // If that pair can cover all other
    // pairs then store its position
    if (count == N)
    {
      pos = i;
    }
  }
  
  // If position not found
  if (pos == -1)
  {
    document.write(pos);
  }
  
  // Otherwise
  else
  {
    document.write(pos + 1);
  }
}
 
// Driver Code
     
    // Given array of pairs
  let arr = [[3, 3], [1, 3],
                 [2, 2], [2, 3],
                 [1, 2]];
  
  let N = arr.length;
  
  // Function Call
  position(arr, N);
 

输出

2

时间复杂度： O(N ² )
辅助空间： O(1)

高效方法：为了优化上述方法，其思想是观察答案总是唯一的，因为总是有一个唯一的对，其中包含最小值和最大值。以下是步骤：

1. 迭代给定的对数组，并从arr[][] 中的所有对中找到最小的第一对和最大的第二对。
2. 在上面的步骤中找到最大值和最小值后，必须存在任何具有arr[i][0] = 最小值和arr[i][1] = 最大值的对。
3. 遍历每个对数组，并检查是否存在arr[i][0]等于最小值且arr[i][1]等于最大值的对。
4. 如果上述步骤中存在任何位置，则打印该位置。
5. 否则，打印-1 。

下面是上述方法的实现：

C++

// C++ program for the above approach
#include 
using namespace std;
 
// Function to find the position of
// the pair that covers every pair
// in the array arr[][]
void position(int arr[][2], int N)
{
    // Postion to store the index
    int pos = -1;
 
    // Stores the maximum second value
    int right = INT_MIN;
 
    // Stores the minimum first value
    int left = INT_MAX;
 
    // Iterate over the array of pairs
    for (int i = 0; i < N; i++) {
 
        // Update right maximum
        if (arr[i][1] > right) {
            right = arr[i][1];
        }
 
        // Update left minimum
        if (arr[i][0] < left) {
 
            left = arr[i][0];
        }
    }
 
    // Iterate over the array of pairs
    for (int i = 0; i < N; i++) {
 
        // If any pair exists with value
        // {left, right} then store it
        if (arr[i][0] == left
            && arr[i][1] == right) {
 
            pos = i + 1;
        }
    }
 
    // Print the answer
    cout << pos << endl;
}
 
// Driver Code
int main()
{
    // Given array of pairs
    int arr[][2] = {{ 3, 3 }, { 1, 3 },
                    { 2, 2 }, { 2, 3 },
                    { 1, 2 }};
 
    int N = sizeof(arr) / sizeof(arr[0]);
 
    // Function Call
    position(arr, N);
}

Java

// Java program for the
// above approach
import java.util.*;
class GFG{
 
// Function to find the position
// of the pair that covers
// every pair in the array arr[][]
static void position(int arr[][],
                     int N)
{
  // Postion to store
  // the index
  int pos = -1;
 
  // Stores the maximum
  // second value
  int right = Integer.MIN_VALUE;
 
  // Stores the minimum
  // first value
  int left = Integer.MAX_VALUE;
 
  // Iterate over the array
  // of pairs
  for (int i = 0; i < N; i++)
  {
    // Update right maximum
    if (arr[i][1] > right)
    {
      right = arr[i][1];
    }
 
    // Update left minimum
    if (arr[i][0] < left)
    {
      left = arr[i][0];
    }
  }
 
  // Iterate over the array
  // of pairs
  for (int i = 0; i < N; i++)
  {
    // If any pair exists
    // with value {left,
    // right} then store it
    if (arr[i][0] == left &&
        arr[i][1] == right)
    {
      pos = i + 1;
    }
  }
 
  // Print the answer
  System.out.print(pos + "\n");
}
 
// Driver Code
public static void main(String[] args)
{
  // Given array of pairs
  int arr[][] = {{3, 3}, {1, 3},
                 {2, 2}, {2, 3},
                 {1, 2}};
 
  int N = arr.length;
 
  // Function Call
  position(arr, N);
}
}
 
// This code is contributed by Princi Singh

蟒蛇3

# Python3 program for the above approach
import sys
 
# Function to find the position of
# the pair that covers every pair
# in the array arr[][]
def position(arr, N):
     
    # Postion to store the index
    pos = -1
 
    # Stores the minimum second value
    right = -sys.maxsize - 1
 
    # Stores the maximum first value
    left = sys.maxsize
 
    # Iterate over the array of pairs
    for i in range(N):
 
        # Update right maximum
        if (arr[i][1] > right):
            right = arr[i][1]
 
        # Update left minimum
        if (arr[i][0] < left):
            left = arr[i][0]
 
    # Iterate over the array of pairs
    for i in range(N):
 
        # If any pair exists with value
        # {left, right then store it
        if (arr[i][0] == left and
            arr[i][1] == right):
            pos = i + 1
 
    # Print the answer
    print(pos)
 
# Driver Code
if __name__ == '__main__':
     
    # Given array of pairs
    arr = [ [ 3, 3 ], [ 1, 3 ],
            [ 2, 2 ], [ 2, 3 ],
            [ 1, 2 ] ]
 
    N = len(arr)
 
    # Function call
    position(arr, N)
 
# This code is contributed by mohit kumar 29

C＃

// C# program for the
// above approach
using System;
class GFG{
 
// Function to find the position
// of the pair that covers
// every pair in the array [,]arr
static void position(int [,]arr,
                     int N)
{
  // Postion to store
  // the index
  int pos = -1;
 
  // Stores the maximum
  // second value
  int right = int.MinValue;
 
  // Stores the minimum
  // first value
  int left = int.MaxValue;
 
  // Iterate over the array
  // of pairs
  for (int i = 0; i < N; i++)
  {
    // Update right maximum
    if (arr[i, 1] > right)
    {
      right = arr[i, 1];
    }
 
    // Update left minimum
    if (arr[i, 0] < left)
    {
      left = arr[i, 0];
    }
  }
 
  // Iterate over the array
  // of pairs
  for (int i = 0; i < N; i++)
  {
    // If any pair exists
    // with value {left,
    // right} then store it
    if (arr[i, 0] == left &&
        arr[i, 1] == right)
    {
      pos = i + 1;
    }
  }
 
  // Print the answer
  Console.Write(pos + "\n");
}
 
// Driver Code
public static void Main(String[] args)
{
  // Given array of pairs
  int [,]arr = {{3, 3}, {1, 3},
                {2, 2}, {2, 3},
                {1, 2}};
 
  int N = arr.GetLength(0);
 
  // Function Call
  position(arr, N);
}
}
 
// This code is contributed by shikhasingrajput

输出

2

时间复杂度： O(N)
辅助空间： O(1)

如果您想与行业专家一起参加直播课程，请参阅Geeks Classes Live