Maximizing Unique Pairs from two arrays

Given two arrays of equal size N, form maximum number of pairs by using their elements, one from the first array and second from the second array, such that an element from each array is used at-most once and the absolute difference between the selected elements used for forming a pair is less than or equal to a given element K.

Examples:

Input : a[] = {3, 4, 5, 2, 1}
        b[] = {6, 5, 4, 7, 15}
          k = 3
Output : 4
The maximum number of pairs that can be formed
using the above 2 arrays is 4 and the corresponding
pairs are [1, 4], [2, 5], [3, 6], [4, 7], we can't 
pair the remaining elements.
Other way of pairing under given constraint is 
[2, 5], [3, 6], [4, 4], but count of pairs here
is 3 which is less than the result 4.



Simple Approach: By taking few examples, we can observe that if we sort both array. Then one by pick closest feasible element for every element, we get the optimal answer.

In this approach we first sort both the arrays and then compare each element of the first array with each element of the second array for the possible pair, if it’s possible to form a pair, we form the pair and move to check for the next possible pair for the next element of the first array.

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ implementation of above approach
#include <bits/stdc++.h>
#define ll long long int
using namespace std;
  
// Returns count of maximum pairs that caan
// be formed from a[] and b[] under given
// constraints.
ll findMaxPairs(ll a[], ll b[], ll n, ll k)
{
    sort(a, a+n); // Sorting the first array.
    sort(b, b+n); // Sorting the second array.
  
    // To keep track of visited elements of b[]
    bool flag[n];
    memset(flag, false, sizeof(flag));
  
    // For every element of a[], find a pair
    // for it and break as soon as a pair is
    // found.
    int result = 0;
    for (int i=0; i<n; i++)
    {
        for (int j=0; j<n; j++)
        {
            if (abs(a[i]-b[j])<=k && flag[j]==false)
            {
                // Increasing the count if a pair is formed.
                result++;
  
                /* Making the corresponding flag array
                   element as 1 indicating the element
                   in the second array element has
                   been used. */
                flag[j] = true;
  
                // We break the loop to make sure an
                // element of a[] is used only once.
                break;
            }
        }
    }
    return result;
}
  
// Driver code
int main()
{
    ll a[] = {10, 15, 20}, b[] = {17, 12, 24};
    int n = sizeof(a)/sizeof(a[0]);
    int k = 3;
    cout << findMaxPairs(a, b, n, k);
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java implementation of above approach
import java.util.*;
  
class solution
{
  
// Returns count of maximum pairs that caan
// be formed from a[] and b[] under given
// constraints.
static int findMaxPairs(int a[], int b[], int n, int k)
{
    Arrays.sort(a); // Sorting the first array.
    Arrays.sort(b); // Sorting the second array.
  
    // To keep track of visited elements of b[]
    boolean []flag = new boolean[n];
    Arrays.fill(flag,false);
  
    // For every element of a[], find a pair
    // for it and break as soon as a pair is
    // found.
    int result = 0;
    for (int i=0; i<n; i++)
    {
        for (int j=0; j<n; j++)
        {
            if (Math.abs(a[i]-b[j])<=k && flag[j]==false)
            {
                // Increasing the count if a pair is formed.
                result++;
  
                /* Making the corresponding flag array
                element as 1 indicating the element
                in the second array element has
                been used. */
                flag[j] = true;
  
                // We break the loop to make sure an
                // element of a[] is used only once.
                break;
            }
        }
    }
    return result;
}
  
// Driver code
public static void main(String args[])
{
    int[] a = {10, 15, 20};
    int[] b = {17, 12, 24};
    int n = a.length;
    int k = 3;
    System.out.println(findMaxPairs(a, b, n, k));
  
}
}
  
// This code is contributed by
// Shashank_Sharma

chevron_right


Python 3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Returns count of maximum pairs 
# that can be formed from a[] and 
# b[] under given constraints.
def findMaxPairs(a, b, n, k):
  
    a.sort() # Sorting the first array.
    b.sort() # Sorting the second array.
  
    # To keep track of visited
    # elements of b[]
    flag = [False] * n
  
    # For every element of a[], find 
    # a pair for it and break as soon 
    # as a pair is found.
    result = 0
    for i in range(n):
        for j in range(n):
            if (abs(a[i] - b[j]) <= k and 
                         flag[j] == False):
      
                # Increasing the count if 
                # a pair is formed.
                result += 1
  
                ''' Making the corresponding flag array
                element as 1 indicating the element
                in the second array element has
                been used. '''
                flag[j] = True
  
                # We break the loop to make sure an
                # element of a[] is used only once.
                break
    return result
  
# Driver code
if __name__ == "__main__":
    a = [10, 15, 20]
    b = [17, 12, 24]
    n = len(a)
    k = 3
    print(findMaxPairs(a, b, n, k))
  
# This code is contributed
# by ChitraNayal

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# implementation of above approach
using System; 
  
class GFG 
  
    // Returns count of maximum pairs that caan 
    // be formed from a[] and b[] under given 
    // constraints. 
    static int findMaxPairs(int []a, int []b, 
                                int n, int k) 
    
        Array.Sort(a); // Sorting the first array. 
        Array.Sort(b); // Sorting the second array. 
  
        // To keep track of visited elements of b[] 
        bool []flag = new bool[n]; 
      
        //Arrays.fill(flag,false); 
  
        // For every element of a[], find a pair 
        // for it and break as soon as a pair is 
        // found. 
        int result = 0; 
        for (int i = 0; i < n; i++) 
        
            for (int j = 0; j < n; j++) 
            
                if (Math.Abs(a[i] - b[j]) <= k && flag[j] == false
                
                    // Increasing the count if a pair is formed. 
                    result++; 
  
                    /* Making the corresponding flag array 
                    element as 1 indicating the element 
                    in the second array element has 
                    been used. */
                    flag[j] = true
  
                    // We break the loop to make sure an 
                    // element of a[] is used only once. 
                    break
                
            
        
        return result; 
    
  
    // Driver code 
    public static void Main() 
    
        int[] a = {10, 15, 20}; 
        int[] b = {17, 12, 24}; 
        int n = a.Length; 
        int k = 3; 
        Console.WriteLine(findMaxPairs(a, b, n, k)); 
    
  
// This code is contributed by Rajput-Ji

chevron_right



Output:

2

Time complexity : O(n2)
Auxiliary Space : O(n)

Efficient Approach: In this approach, rather than checking all the possible combination of pairs, we optimize our code by checking only the feasible combination of pairs using the 2 pointer approach.

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

#include <bits/stdc++.h>
#define ll long long int
using namespace std;
  
// Returns count of maximum pairs that caan
// be formed from a[] and b[] under given
// constraints.
ll findMaxPairs(ll a[], ll b[], ll n, ll k)
{
    sort(a, a+n); // Sorting the first array.
    sort(b, b+n); // Sorting the second array.
  
    int result = 0;
    for (int i=0, j=0; i<n && j<n;)
    {
        if (abs(a[i] - b[j]) <= k)
        {
            result++;
  
            // Increasing array pointer of
            // both the first and the second array.
            i++;
            j++;
        }
  
        // Increasing array pointer of the second array.
        else if(a[i] > b[j])
            j++;
  
        // Increasing array pointer of the first array.
        else
            i++;
    }
    return result;
}
  
// Driver code
int main()
{
    ll a[] = {10, 15, 20};
    ll b[] = {17, 12, 24};
    int n = sizeof(a)/sizeof(a[0]);
    int k = 3;
    cout << findMaxPairs(a, b, n, k);
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program for Maximizing Unique Pairs 
// from two arrays
import java.util.*;
  
class GFG
{
  
// Returns count of maximum pairs that caan
// be formed from a[] and b[] under given
// constraints.
static int findMaxPairs(int a[], int b[], 
                        int n, int k)
{
    Arrays.sort(a); // Sorting the first array.
    Arrays.sort(b); // Sorting the second array.
  
    int result = 0;
    for (int i = 0, j = 0; i < n && j < n;)
    {
        if (Math.abs(a[i] - b[j]) <= k)
        {
            result++;
  
            // Increasing array pointer of
            // both the first and the second array.
            i++;
            j++;
        }
  
        // Increasing array pointer 
        // of the second array.
        else if(a[i] > b[j])
            j++;
  
        // Increasing array pointer 
        // of the first array.
        else
            i++;
    }
    return result;
}
  
// Driver code
public static void main(String args[])
{
    int a[] = {10, 15, 20};
    int b[] = {17, 12, 24};
    int n = a.length;
    int k = 3;
    System.out.println(findMaxPairs(a, b, n, k));
}
}
  
// This code is contributed by
// Sanjit_Prasad

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 program for
# Maximizing Unique Pairs 
# from two arrays
  
# Returns count of maximum pairs that caan 
# be formed from a[] and b[] under given 
# constraints. 
def findMaxPairs(a,b,n,k):
      
    # Sorting the first array.
    a.sort()
      
    # Sorting the second array.
    b.sort() 
      
    result =0
    j=0
    for i in range(n):
        if j<n:
            if abs(a[i]-b[j])<=k:
                result+=1
  
            # Increasing array pointer of 
            # both the first and the second array. 
                j +=1
                  
            # Increasing array pointer of 
            # the second array. 
            elif a[i]>b[j]:
                j+=1
    return result
  
# Driver code
if __name__=='__main__':
    a = [10,15,20]
    b = [17,12,24]
    n = len(a)
    k =3
    print(findMaxPairs(a,b,n,k))
  
# This code is contributed by 
# Shrikant13

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# program for Maximizing Unique Pairs 
// from two arrays
using System;
  
class GFG
{
  
// Returns count of maximum pairs that caan
// be formed from a[] and b[] under given
// constraints.
static int findMaxPairs(int []a, int []b, 
                        int n, int k)
{
    Array.Sort(a); // Sorting the first array.
    Array.Sort(b); // Sorting the second array.
  
    int result = 0;
    for (int i = 0, j = 0; i < n && j < n;)
    {
        if (Math.Abs(a[i] - b[j]) <= k)
        {
            result++;
  
            // Increasing array pointer of
            // both the first and the second array.
            i++;
            j++;
        }
  
        // Increasing array pointer 
        // of the second array.
        else if(a[i] > b[j])
            j++;
  
        // Increasing array pointer 
        // of the first array.
        else
            i++;
    }
    return result;
}
  
// Driver code
public static void Main(String []args)
{
    int []a = {10, 15, 20};
    int []b = {17, 12, 24};
    int n = a.Length;
    int k = 3;
    Console.WriteLine(findMaxPairs(a, b, n, k));
}
}
  
// This code has been contributed by 29AjayKumar

chevron_right



Output:

2

Time complexity : O(n Log n)
Auxiliary Space : O(1)

This article is contributed by Aditya Gupta. 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 write comments if you find anything incorrect, or you want to share more information about the topic discussed above.



My Personal Notes arrow_drop_up



Article Tags :
Practice Tags :


2


Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.