GeeksforGeeks App
Open App
Browser
Continue

# Kth largest pairwise product possible from given two Arrays

Given two arrays arr[] and brr[] containing integers. The task is to find the Kth largest product of a pair (arr[i], brr[j]).

Examples:

Input: arr[] = {1, -2, 3}, brr[] = {3, -4, 0}, K = 3
Output: 3
Explanation: All product combinations in descending order are : [9, 8, 3, 0, 0, 0, -4, -6, -12] and 3rd largest element is 3.

Input: arr[] = {-1, -5, -3}, brr[] = {-3, -4, 0}, K =5
Output: 4
Explanation: All product combinations in descending order are : [20, 15, 12, 9, 4, 3, 0, 0, 0] and 5th largest element is 4.

Naive Approach: Generate all the possible products combination for each element in array arr[] with each element in array brr[]. Then sort the array of results and return the Kth element of the results array.

## C++

 #include using namespace std;int solve(int a[ ], int n, int b[ ], int m, int k) {  vector ans;  for (int i = 0; i < n; i++) {    for (int j = 0; j < m; j++) {       // take product      int prod = a[i] * b[j];      ans.push_back(prod);    }  }   // Sort array in descending order  sort(ans.begin(), ans.end(), greater());   // Finally return (k - 1)th index  // as indexing begin from 0.  return ans[k - 1];} // Driver codeint main(){   int arr[ ] = { 1, -2, 3 };  int brr[ ] = { 3, -4, 0 };  int K = 3;  int n = sizeof(arr) / sizeof(int);  int m = sizeof(brr) / sizeof(int);     // Function Call  int val = solve(arr, n, brr, m, K);   cout << val;   return 0;} // This code is contributed by hrithikgarg03188

## Java

 // Java code for the above approachimport java.util.Collections;import java.util.LinkedList;import java.util.List; class GFG {   static int solve(int[] a, int[] b, int k) {    List ans = new LinkedList<>();    int n = a.length;    int m = b.length;     for (int i = 0; i < n; i++) {      for (int j = 0; j < m; j++) {         // take product        int prod = a[i] * b[j];        ans.add(prod);      }    }     // Sort array in descending order    Collections.sort(ans, (x, y) -> y - x);     // Finally return (k - 1)th index    // as indexing begins from 0.    return (ans.get(k - 1));  }   // Driver Code  public static void main(String[] args)  {     int[] arr = { 1, -2, 3 };    int[] brr = { 3, -4, 0 };    int K = 3;     // Function Call    int val = solve(arr, brr, K);     System.out.println(val);   }} // This code is contributed by 29AjayKumar

## Python3

 # Python program for above approachdef solve(a, b, k):    ans = []    n = len(a)    m = len(b)     for i in range(n):        for j in range(m):             # take product            prod = a[i]*b[j]            ans.append(prod)     # Sort array in descending order    ans.sort(reverse = True)     # Finally return (k-1)th index    # as indexing begins from 0.    return (ans[k-1])  # Driver Codearr = [1, -2, 3]brr = [3, -4, 0]K = 3 # Function Callval = solve(arr, brr, K) print(val)

## C#

 // C# code for the above approachusing System;using System.Collections.Generic; public class GFG {   static int solve(int[] a, int[] b, int k) {    List ans = new List();    int n = a.Length;    int m = b.Length;     for (int i = 0; i < n; i++) {      for (int j = 0; j < m; j++) {         // take product        int prod = a[i] * b[j];        ans.Add(prod);      }    }     // Sort array in descending order    ans.Sort((x, y) => y - x);     // Finally return (k - 1)th index    // as indexing begins from 0.    return (ans[k - 1]);  }   // Driver Code  public static void Main(String[] args)  {     int[] arr = { 1, -2, 3 };    int[] brr = { 3, -4, 0 };    int K = 3;     // Function Call    int val = solve(arr, brr, K);     Console.WriteLine(val);   }} // This code is contributed by 29AjayKumar

## Javascript



Output:

3

Time Complexity: O(N*M + (N+M) * Log(N+M))
Auxiliary Space: O(N+M)

Efficient Approach: This problem can be solved by using the Greedy Approach and Heaps. Follow the steps below to solve the given problem.

• Sort the brr[] array.
• Keep larger size array in the array arr[].
• Create a max heap to store the elements with their respective indices.
• Traverse each element from array arr[]. The element can be either positive or negative.
• Positive: Multiply current element from arr[] with the largest element of sorted array brr[]. To ensure that maximum element is obtained.
• Negative: In this case multiply with the smallest value, i.e. with the first element from array brr[]. This is due to the property of negation, as a larger value can be obtained by multiplying with the smallest one.
• Insert three values into heap such that : ( product, i, j ) where i & j are the indices of arrays arr[] and brr[].
• Now run a for loop K times and pop elements from the heap.
• Now check if the value present at arr[i] is positive or negative
• Positive: So next_j = ( current_j – 1) because as max heap is been used, all the higher indices might have been already popped from the heap.
• Negative:  next_j = (current_j +1) because all the smaller values yielding larger elements might have been already popped from the heap.

Note:  Max heap is implemented with the help of min-heap, by negating the signs of the values while inserting them into the heap in Python.

Below is the implementation of the above approach.

## C++

 // C++program for above approach#includeusing namespace std; class Pair {  public:  int val;  int i;  int j;   Pair(int val, int i, int j)  {    this->val = val;    this->i = i;    this->j = j;  }}; struct comparator {  bool operator()(Pair const& p1, Pair const& p2)  {         // return "true" if "p1" is ordered    // before "p2", for example:    return p1.val < p2.val;  }}; int solve(int* a, int* b,  int k){     // Sorting array b in ascending order  sort(b, b + k);  int n = k;  int m = k;   // Checking if size(a) > size(b)  if (n < m) {    // Otherwise swap the arrays    return solve(b, a, k);  }   // Create a max heap  priority_queue, comparator> heap;   // Traverse all elements in array a  for (int i = 0; i < n; i++) {    int curr = a[i];         // curr element is negative    if (curr < 0) {             // Product with smallest value      int val = curr * b[0];             // Pushing the value and i as well jth index      heap.push(Pair(val, i, 0));    }    else    {             // Product with largest value      int val = curr * b[m - 1];             // Pushing the value and i as well jth index      heap.push(Pair(val, i, m - 1));    }  }   // Subtract 1 due to zero indexing  k--;   // Remove k-1 largest items from heap  for (int i = 0; i < k; i++) {    Pair pair = heap.top();    heap.pop();    int val = pair.val;    int iIndex = pair.i;    int jIndex = pair.j;         // if a[i] is negative, increment ith index    int nextJ;    if (a[iIndex] < 0) {      nextJ = jIndex + 1;    }    else    {             // if a[i] is positive, decrement jth index      nextJ = jIndex - 1;    }         // if index is valid    if (nextJ >= 0 && nextJ < m) {      int newVal = a[iIndex] * b[nextJ];             // Pushing new_val in the heap      heap.push(Pair(newVal, iIndex, nextJ));    }  }   // Finally return first val in the heap  return heap.top().val;} int main(){  int arr[] = { 1, -2, 3 };  int brr[] = { 3, -4, 0 };  int K = 3;   // Function Call  int val = solve(arr, brr, K);   // Print the result  cout << val << endl;   return 0;} // The code is contributed by Nidhi goel.

## Java

 // Java program for above approach import java.io.*;import java.util.*; class Pair {  int val;  int i;  int j;   public Pair(int val, int i, int j)  {    this.val = val;    this.i = i;    this.j = j;  }} class GFG {   static int solve(int[] a, int[] b, int k)  {    // Sorting array b in ascending order    Arrays.sort(b);    int n = a.length;    int m = b.length;     // Checking if size(a) > size(b)    if (n < m) {      // Otherwise swap the arrays      return solve(b, a, k);    }     // Create a max heap    PriorityQueue heap = new PriorityQueue<>(      (p1, p2) -> p2.val - p1.val);     // Traverse all elements in array a    for (int i = 0; i < n; i++) {      int curr = a[i];      // curr element is negative      if (curr < 0) {        // Product with smallest value        int val = curr * b[0];        // Pushing the value and i as well jth index        heap.add(new Pair(val, i, 0));      }      else {        // Product with largest value        int val = curr * b[m - 1];        // Pushing the value and i as well jth index        heap.add(new Pair(val, i, m - 1));      }    }     // Subtract 1 due to zero indexing    k--;     // Remove k-1 largest items from heap    for (int i = 0; i < k; i++) {      Pair pair = heap.poll();      int val = pair.val;      int iIndex = pair.i;      int jIndex = pair.j;      // if a[i] is negative, increment ith index      int nextJ;      if (a[iIndex] < 0) {        nextJ = jIndex + 1;      }      else {        // if a[i] is positive, decrement jth index        nextJ = jIndex - 1;      }      // if index is valid      if (nextJ >= 0 && nextJ < m) {        int newVal = a[iIndex] * b[nextJ];        // Pushing new_val in the heap        heap.add(new Pair(newVal, iIndex, nextJ));      }    }     // Finally return first val in the heap    return heap.peek().val;  }   public static void main(String[] args)  {    int[] arr = { 1, -2, 3 };    int[] brr = { 3, -4, 0 };    int K = 3;     // Function Call    int val = solve(arr, brr, K);     // Print the result    System.out.println(val);  }} // This code is contributed by lokesh.

## Python3

 # Python program for above approachfrom heap import heappush as push, heappop as pop  def solve(a, b, k):     # Sorting array b in ascending order    b.sort()    n, m = len(a), len(b)     # Checking if size(a) > size(b)     if (n < m):         # Otherwise swap the arrays         return solve(b, a, k)     heap = []     # Traverse all elements in array a    for i in range(n):         curr = a[i]         # curr element is negative        if (curr < 0):             # Product with smallest value            val = curr * b[0]             # Pushing negative val due to max heap            # and i as well jth index            push(heap, (-val, i, 0))         else:             # Product with largest value            val = curr * b[-1]             # Pushing negative val due to max heap            # and i as well jth index            push(heap, (-val, i, m-1))     # Subtract 1 due to zero indexing    k = k-1     # Remove k-1 largest items from heap    for _ in range(k):         val, i, j = pop(heap)        val = -val         # if a[i] is negative, increment ith index         if (a[i] < 0):            next_j = j + 1         # if a[i] is positive, decrement jth index        else:            next_j = j-1         # if index is valid        if (0 <= next_j < m):             new_val = a[i] * b[next_j]             # Pushing new_val in the heap            push(heap, (-new_val, i, next_j))     # Finally return first val in the heap    return -(heap[0][0])  # Driver Codearr = [1, -2, 3]brr = [3, -4, 0]K = 3 # Function Callval = solve(arr, brr, K) # Print the resultprint(val)

## C#

 // C# program for above approach using System;using System.Collections.Generic; class Pair : IComparable{    public int val;    public int i;    public int j;     public Pair(int val, int i, int j)    {        this.val = val;        this.i = i;        this.j = j;    }     public int CompareTo(Pair other)    {        return this.val - other.val;    }} public class GFG{    static int solve(int[] a, int[] b, int k)    {        // Sorting array b in ascending order        Array.Sort(b);        int n = a.Length;        int m = b.Length;         // Checking if size(a) > size(b)        if (n < m)        {            // Otherwise swap the arrays            return solve(b, a, k);        }         // Create a max heap        SortedSet heap = new SortedSet();         // Traverse all elements in array a        for (int i = 0; i < n; i++)        {            int curr = a[i];            // curr element is negative            if (curr < 0)            {                // Product with smallest value                int val = curr * b[0];                // Pushing the value and i as well jth index                heap.Add(new Pair(val, i, 0));            }            else            {                // Product with largest value                int val = curr * b[m - 1];                // Pushing the value and i as well jth index                heap.Add(new Pair(val, i, m - 1));            }        }         // Subtract 1 due to zero indexing        k--;         // Remove k-1 largest items from heap        for (int i = 0; i < k; i++)        {            Pair pair = heap.Max;            heap.Remove(pair);            int iIndex = pair.i;            int jIndex = pair.j;            // if a[i] is negative, increment ith index            int nextJ;            if (a[iIndex] < 0)            {                nextJ = jIndex + 1;            }            else            {                // if a[i] is positive, decrement jth index                nextJ = jIndex - 1;            }            // if index is valid            if (nextJ >= 0 && nextJ < m)            {                int newVal = a[iIndex] * b[nextJ];                // Pushing new_val in the heap                heap.Add(new Pair(newVal, iIndex, nextJ));            }        }         // Finally return first val in the heap        return heap.Max.val;    }     static void Main(string[] args)    {        int[] arr = { 1, -2, 3 };        int[] brr = { 3, -4, 0 };        int K = 3;                 // Function Call        int val = solve(arr, brr, K);         // Print the result        Console.WriteLine(val);    }}

## Javascript

 // Javascript program for above approachclass Pair {       constructor(val, i, j)  {    this.val = val;    this.i = i;    this.j = j;  }} function sortFunction(a, b) {    return a[0] - b[0];} function solve(a, b, k){     // Sorting array b in ascending order  b.sort();  let n = k;  let m = k;   // Checking if size(a) > size(b)  if (n < m) {    // Otherwise swap the arrays    return solve(b, a, k);  }   // Create a max heap  let heap = [];   // Traverse all elements in array a  for (let i = 0; i < n; i++) {    let curr = a[i];         // curr element is negative    if (curr < 0) {             // Product with smallest value      let val = curr * b[0];             // Pushing the value and i as well jth index      heap.push([val, i, 0]);      heap.sort(sortFunction);    }    else    {             // Product with largest value      let val = curr * b[m - 1];             // Pushing the value and i as well jth index      heap.push([val, i, m - 1]);      heap.sort(sortFunction);    }  }   // Subtract 1 due to zero indexing  k--;   // Remove k-1 largest items from heap  for (let i = 0; i < k; i++) {    let pair = heap[heap.length - 1];    heap.pop();    let val = pair[0];    let iIndex = pair[1];    let jIndex = pair[2];         // if a[i] is negative, increment ith index    let nextJ = 0;    if (a[iIndex] < 0) {      nextJ = jIndex + 1;    }    else    {             // if a[i] is positive, decrement jth index      nextJ = jIndex - 1;    }         // if index is valid    if (nextJ >= 0 && nextJ < m) {      let newVal = a[iIndex] * b[nextJ];             // Pushing new_val in the heap      heap.push([newVal, iIndex, nextJ]);      heap.sort(sortFunction);    }  }   // Finally return first val in the heap  return heap[heap.length - 1][0];} let arr =  [1, -2, 3];let brr =  [3, -4, 0];let K = 3; // Function Calllet val = solve(arr, brr, K); // Print the resultconsole.log(val); // The code is contributed by Nidhi goel.

Output:

3

Time Complexity: O(M*Log(M) + K*Log(N))
Auxiliary Space: O(N)

My Personal Notes arrow_drop_up