Skip to content
Related Articles

Related Articles

Improve Article
Maximize count of pairs (i, j) from two arrays having element from first array not exceeding that from second array
  • Last Updated : 18 Nov, 2020

Given two arrays arr1[] and arr2[] of lengths N and M respectively, the task is to find the maximum number of pairs (i, j) such that 2 * arr1[i] ≤ arr2[j] (1 ≤ i ≤ N and 1 ≤ j ≤ M).

Note: Any array element can be part of a single pair.

Examples:

Input: N = 3, arr1[] = {3, 2, 1}, M = 4, arr2[] = {3, 4, 2, 1}
Output: 2
Explanation:
Only two pairs can be chosen:

  • (1, 3): Choose elements arr1[3] and arr2[1].
    Therefore, pair = (arr1[3], arr2[1]) = (1, 3). Also, 2 * arr1[3] ≤ arr2[1].
    Now elements at positions 3 and 1 of arr1[] and arr2[] respectively, cannot be chosen.
  • (2, 2): Choose elements arr1[2] and arr2[2].
    Therefore, pair = (arr1[2], arr2[2]) = (2, 4). Also, 2*arr1[2] <= arr2[2].
    Now elements at position 2 of arr1[] and arr2[] cannot be chosen.

Input: N = 1, arr1[] = {40}, M = 4, arr2[] = {10, 20, 30, 40}
Output: 0
Explanation: 
No Possible Pair exists which satisfies the condition.



 

Naive Approach: The simplest approach is to first sort both the arrays and for each element arr1[i], greedily find the element that is just greater than or equal to the value 2 * arr1[i] in the given array arr2[] and then remove that element from arr2[] by incrementing the total number of required pairs by 1. After traversing the whole array arr1[], print the number of pairs.

Time Complexity: O(N * M), where N and M are the lengths of the given array.
Auxiliary Space: O(N+M)

Efficient Approach: The idea is to use the Greedy Algorithm by finding an element in arr2[] that is just greater than or equal to the value 2*arr1[i] where 0<=i<=N-1. Follow the below steps to solve the problem:

  1. Sort the array arr1[] and initialize a variable ans to store the maximum number of pairs.
  2. Add all the elements of arr2[] in Max Heap.
  3. Traverse the array arr1[] from i = (N – 1) to 0 in non-increasing order.
  4. For each element arr1[i], remove the peek element from the Max Heap until 2*arr1[i] becomes smaller than or equal to the peek element and increment ans by 1 if such element is found.
  5. After traversing the whole array, print ans as the maximum number of pairs.

Below is the implementation of the above approach:

C++




// C++ program for the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to return the maximum
// number of required pairs
int numberOfPairs(int arr1[], int n,
                  int arr2[], int m)
{
 
    // Max Heap to add values of arar2[]
    priority_queue<int> pq;
    int i, j;
 
    // Sort the array arr1[]
    sort(arr1, arr1 + n);
 
    // Push all arr2[] into Max Heap
    for (j = 0; j < m; j++) {
        pq.push(arr2[j]);
    }
 
    // Initialize the ans
    int ans = 0;
 
    // Traverse the arr1[] in
    // decreasing order
    for (i = n - 1; i >= 0; i--) {
 
        // Remmove element until a
        // required pair is found
        if (pq.top() >= 2 * arr1[i]) {
            ans++;
           
            pq.pop();
        }
    }
 
    // Return maximum number of pairs
    return ans;
}
 
// Driver Code
int main()
{
    // Given arrays
    int arr1[] = { 3, 1, 2 };
    int arr2[] = { 3, 4, 2, 1 };
 
    int N = sizeof(arr1) / sizeof(arr1[0]);
    int M = sizeof(arr2) / sizeof(arr2[0]);
 
    // Function Call
    cout << numberOfPairs(arr1, N,
                          arr2, M);
    return 0;
}

Java




// Java program for the above approach
import java.io.*;
import java.util.*;
 
class GFG{
  
// Function to return the maximum
// number of required pairs
static int numberOfPairs(int[] arr1, int n,
                         int[] arr2, int m)
{
     
    // Max Heap to add values of arr2[]
    PriorityQueue<Integer> pQueue =
    new PriorityQueue<Integer>(
        new Comparator<Integer>()
    {
        public int compare(Integer lhs,
                           Integer rhs)
        {
            if (lhs < rhs)
            {
                return + 1;
            }
            if (lhs.equals(rhs))
            {
                return 0;
            }
            return -1;
        }
    });
     
    int i, j;
     
    // Sort the array arr1[]
    Arrays.sort(arr1);
     
    // Push all arr2[] into Max Heap
    for(j = 0; j < m; j++)
    {
        pQueue.add(arr2[j]);
    }
     
    // Initialize the ans
    int ans = 0;
     
    // Traverse the arr1[] in
    // decreasing order
    for(i = n - 1; i >= 0; i--)
    {
         
        // Remove element until a
        // required pair is found
        if (pQueue.peek() >= 2 * arr1[i])
        {
            ans++;
            pQueue.poll();
        }
    }
     
    // Return maximum number of pairs
    return ans;
}
 
// Driver Code
public static void main (String[] args)
{
     
    // Given arrays
    int[] arr1 = { 3, 1, 2 };
    int[] arr2 = { 3, 4, 2, 1 };
     
    int N = 3;
    int M = 4;
     
    // Function call
    System.out.println(numberOfPairs(arr1, N,
                                     arr2, M));
}
}
 
// This code is contributed by sallagondaavinashreddy7

Python3




# Python3 program for the above approach
 
# Function to return the maximum
# number of required pairs
def numberOfPairs(arr1, n, arr2, m):
   
    # Max Heap to add values of arr2[]
    pq = []
 
    # Sort the array arr1[]
    arr1.sort(reverse = False)
 
    # Push all arr2[] into Max Heap
    for j in range(m):
        pq.append(arr2[j])
 
    # Initialize the ans
    ans = 2
 
    # Traverse the arr1[] in
    # decreasing order
    i = n - 1
    while (i >= 0):
       
        # Remove element until a
        # required pair is found
        pq.sort(reverse = False)
         
        if (pq[0] >= 2 * arr1[i]):
            ans += 1
            print(pq[0])
            pq.remove(pq[0])
             
        i -= 1
 
    # Return maximum number of pairs
    return ans
 
# Driver Code
if __name__ == '__main__':
   
    # Given arrays
    arr1 = [ 3, 2, 1 ]
    arr2 = [ 3, 4, 2, 1 ]
 
    N = len(arr1)
    M = len(arr2)
 
    # Function Call
    print(numberOfPairs(arr1, N, arr2, M))
     
# This code is contributed by ipg2016107
Output: 
2








 

Time Complexity: O(N*log N + M*log M), where N and M are the lengths of the given array.
Auxiliary Space: O(N+M)

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 Geeks Classes Live 




My Personal Notes arrow_drop_up
Recommended Articles
Page :