给定两个阵列ARR1 []和分别的长度N和M ARR2 []中，任务是找到对的最大数目(I，J)，使得2 * ARR1 [I]≤ARR2 [J](1≤I≤ N和1≤j≤M )。
注意：任何数组元素都可以是一对对的一部分。
例子：
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.
天真的方法：最简单的方法是先对数组进行排序，然后对每个元素arr1 [i]贪婪地找到给定数组arr2 []中刚好大于或等于2 * arr1 [i]的元素，然后然后通过将所需对的总数增加1来从arr2 []中删除该元素。遍历整个数组arr1 []后，打印对数。
时间复杂度： O(N * M)，其中N和M是给定数组的长度。
辅助空间： O(N + M)
高效方法：这个想法是通过在arr2 []中找到一个刚好大于或等于2 * arr1 [i]的元素(其中0 <= i <= N-1 )来使用贪婪算法。请按照以下步骤解决问题：
- 对数组arr1 []进行排序，并初始化变量ans以存储最大对数。
- 在Max Heap中添加arr2 []的所有元素。
- 将数组arr1 []从i =(N – 1)遍历到非递增顺序为0 。
- 对于每个元素arr1 [i] ，从最大堆中移除peek元素，直到2 * arr1 [i]小于或等于peek元素，并在找到ans时将ans递增1 。
- 遍历整个数组后，将ans打印为最大对数。
下面是上述方法的实现：
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 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 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输出：
2
时间复杂度： O(N * log N + M * log M)，其中N和M是给定数组的长度。
辅助空间： O(N + M)