Find three element from different three arrays such that a + b + c = sum

Given three integer arrays and a “sum”, the task is to check if there are three elements a, b, c such that a + b + c = sum and a, b and c belong to three different arrays. 

Examples : 

Input : a1[] = { 1 , 2 , 3 , 4 , 5 };
    a2[] = { 2 , 3 , 6 , 1 , 2 };
    a3[] = { 3 , 2 , 4 , 5 , 6 };  
        sum = 9
Output : Yes
1  + 2  + 6 = 9  here 1 from a1[] and 2 from
a2[] and 6 from a3[]   
    
Input : a1[] = { 1 , 2 , 3 , 4 , 5 };
    a2[] = { 2 , 3 , 6 , 1 , 2 };
    a3[] = { 3 , 2 , 4 , 5 , 6 };   
         sum = 20 
Output : No 

A naive approach is to run three loops and check sum of three element form different arrays equal to given number if find then print exist and otherwise print not exist.  

Algorithm:

• Define a function findTriplet that takes in three integer arrays a1, a2, a3, their respective sizes n1, n2, n3, and the integer variable sum.
• Loop through each element of a1, a2, and a3 using three nested for-loops.
• If the sum of the current triplet of elements (a1[i], a2[j], a3[k]) is equal to sum, return true.
• If no such triplet is found, return false.
• In the main function, define three integer arrays a1, a2, a3, and the integer variable sum.
• Get the size of each array using sizeof operator and divide it by the size of a single element to get the size of the array in terms of number of elements.
• Call the findTriplet function with a1, a2, a3, n1, n2, n3, and sum as arguments.
• If the function returns true, print “Yes“. Otherwise, print “No“.
   

Implementation:

Yes

Time Complexity : O(n³) 
Auxiliary Space: O(1) 

An efficient solution is to store all elements of first array in hash table (unordered_set in C++) and calculate sum of two elements last two array elements one by one and subtract from given number k and check in hash table if it exists in the hash table then print exist and otherwise not exist. 

1. Store all elements of first array in hash table
2. Generate all pairs of elements from two arrays using
   nested loop. For every pair (a1[i], a2[j]), check if
   sum - (a1[i] + a2[j]) exists in hash table. If yes
   return true.      

Below is the implementation of above idea.  

Yes

Time Complexity: O(n²) 
Auxiliary Space: O(n) 

Another efficient approach ( Space optimization ) : we will run two loops, then we will search for required sum in third loop using binary search .

Below is the implementation of the above approach :

YES

Time Complexity: O(n1*n2*log n3)
Auxiliary Space: O(1)