# 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--) {`   `        ``// 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);` `    ``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`

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.

My Personal Notes arrow_drop_up If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.