 GeeksforGeeks App
Open App Browser
Continue

# Maximize count of pairs (i, j) from two arrays having element from first array not exceeding that from second array

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 and arr2.
Therefore, pair = (arr1, arr2) = (1, 3). Also, 2 * arr1 ≤ arr2.
Now elements at positions 3 and 1 of arr1[] and arr2[] respectively, cannot be chosen.
• (2, 2): Choose elements arr1 and arr2.
Therefore, pair = (arr1, arr2) = (2, 4). Also, 2*arr1 <= arr2.
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 ``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--) {` `        ``// Remove 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);``    ``int` `M = ``sizeof``(arr2) / ``sizeof``(arr2);` `    ``// 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 pQueue =``    ``new` `PriorityQueue(``        ``new` `Comparator()``    ``{``        ``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`

## C#

 `using` `System;``using` `System.Collections.Generic;` `class` `Program``{` `  ``// 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[]``    ``List<``int``> pq = ``new` `List<``int``>();` `    ``// Sort the array arr1[]``    ``Array.Sort(arr1);` `    ``// Push all arr2[] into Max Heap``    ``for` `(``int` `j = 0; j < m; j++) {``      ``pq.Add(arr2[j]);``    ``}` `    ``// Initialize the ans``    ``int` `ans = 2;` `    ``// Traverse the arr1[] in decreasing order``    ``int` `i = n - 1;``    ``while` `(i >= 0) {``      ``// Remove element until a required pair is found``      ``pq.Sort();``      ``if` `(pq >= 2 * arr1[i]) {``        ``ans += 1;``        ``Console.WriteLine(pq);``        ``pq.Remove(pq);``      ``}``      ``i -= 1;``    ``}` `    ``// Return maximum number of pairs``    ``return` `ans;``  ``}` `  ``static` `void` `Main(``string``[] args) {``    ``// Given arrays``    ``int``[] arr1 = ``new` `int``[] { 3, 2, 1 };``    ``int``[] arr2 = ``new` `int``[] { 3, 4, 2, 1 };` `    ``int` `N = arr1.Length;``    ``int` `M = arr2.Length;` `    ``// Function Call``    ``Console.WriteLine(numberOfPairs(arr1, N, arr2, M));``  ``}``}`

## Javascript

 ``

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)

My Personal Notes arrow_drop_up