Related Articles

# Maximize product of array by replacing array elements with its sum or product with element from another array

• Difficulty Level : Expert
• Last Updated : 22 Jun, 2021

Given two arrays A[] and B[] consisting of N integers, the task is to update array A[] by assigning every array element A[i] to a single element B[j] and update A[i] to A[i] + B[j] or A[i] * B[j], such that the product of the array A[] is maximized.

Note: Every array element in both the arrays can be paired with a single element from the other array only once.

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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

Examples:

Input: A[] = {1, 1, 6}, B[] = {1, 2, 3}
Output: 108
Explanation:

1. Update A = A + B, A[] modifies to {2, 1, 6}
2. Update A = A + B, A[] modifies to {2, 3, 6}
3. Update A = A * B, A[] modifies to {6, 3, 6}

Therefore, the product of the array A[] is 6 * 3 * 6 = 108.

Input: A[] = {1, 1, 10}, B[] ={1, 1, 1}
Output: 60
Explanation:

1. Update A = A + B, A[] modifies to {2, 1, 10}
2. Update A = A + B, A[] modifies to {2, 2, 10}
3. Update A = A * B, A[] modifies to {3, 2, 10}

Approach: The above problem can be solved by using a priority queue(min-heap). Follow the steps below to solve the problem:

• Sort the array B[].
• Insert all elements of array A[] into priority queue in order to get minimum elements each time.
• Traverse the given array B[] using variable j and popped an element from the priority queue as the maximum of minE + B[j] or minE*B[j] and push this maximum into the priority queue.
• After the above steps, the product of elements in the priority queue is the required result.

Below is the implementation of the above approach :

## C++

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `// Function to find the largest``// product of array A[]``int` `largeProduct(vector<``int``> A,``                 ``vector<``int``> B, ``int` `N)``{``    ` `    ``// Base Case``    ``if` `(N == 0)``        ``return` `0;` `    ``// Store all the elements of``    ``// the array A[]``    ``priority_queue<``int``, vector<``int``>,``           ``greater<``int``>> pq;` `    ``for``(``int` `i = 0; i < N; i++)``        ``pq.push(A[i]);` `    ``// Sort the Array B[]``    ``sort(B.begin(), B.end());` `    ``// Traverse the array B[]``    ``for``(``int` `i = 0; i < N; i++)``    ``{``        ` `        ``// Pop minimum element``        ``int` `minn = pq.top();``        ``pq.pop();` `        ``// Check which operation is``        ``// producing maximum element``        ``int` `maximized_element = max(minn * B[i],``                                    ``minn + B[i]);` `        ``// Insert resultant element``        ``// into the priority queue``        ``pq.push(maximized_element);``    ``}` `    ``// Evaluate the product``    ``// of the elements of A[]``    ``int` `max_product = 1;``    ``while` `(pq.size() > 0)``    ``{``        ``max_product *= pq.top();``        ``pq.pop();``    ``}` `    ``// Return the maximum product``    ``return` `max_product;``}` `// Driver Code``int` `main()``{``    ` `    ``// Given arrays``    ``vector<``int``> A = { 1, 1, 10 };``    ``vector<``int``> B = { 1, 1, 1 };` `    ``int` `N = 3;` `    ``// Function Call``    ``cout << largeProduct(A, B, N);``}` `// This code is contributed by mohit kumar 29`

## Java

 `// Java program for the above approach` `import` `java.io.*;``import` `java.util.*;``class` `GFG {` `    ``// Function to find the largest``    ``// product of array A[]``    ``public` `static` `int` `largeProduct(``        ``int` `A[], ``int` `B[], ``int` `N)``    ``{``        ``// Base Case``        ``if` `(N == ``0``)``            ``return` `0``;` `        ``// Store all the elements of``        ``// the array A[]``        ``PriorityQueue pq``            ``= ``new` `PriorityQueue<>();` `        ``for` `(``int` `i = ``0``; i < N; i++)``            ``pq.add(A[i]);` `        ``// Sort the Array B[]``        ``Arrays.sort(B);` `        ``// Traverse the array B[]``        ``for` `(``int` `i = ``0``; i < N; i++) {` `            ``// Pop minimum element``            ``int` `minn = pq.poll();` `            ``// Check which operation is``            ``// producing maximum element``            ``int` `maximized_element``                ``= Math.max(minn * B[i],``                           ``minn + B[i]);` `            ``// Insert resultant element``            ``// into the priority queue``            ``pq.add(maximized_element);``        ``}` `        ``// Evaluate the product``        ``// of the elements of A[]``        ``int` `max_product = ``1``;``        ``while` `(pq.size() > ``0``) {` `            ``max_product *= pq.poll();``        ``}` `        ``// Return the maximum product``        ``return` `max_product;``    ``}` `    ``// Driver Code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``// Given arrays``        ``int` `A[] = { ``1``, ``1``, ``10` `};``        ``int` `B[] = { ``1``, ``1``, ``1` `};` `        ``int` `N = ``3``;` `        ``// Function Call``        ``System.out.println(``            ``largeProduct(A, B, N));``    ``}``}`

## Python3

 `# Python program for the above approach` `# Function to find the largest``# product of array A[]``def` `largeProduct(A, B, N):``  ` `    ``# Base Case``    ``if``(N ``=``=` `0``):``        ``return` `0``      ` `    ``# Store all the elements of``    ``# the array A[]``    ``pq ``=` `[]``    ``for` `i ``in` `range``(N):``        ``pq.append(A[i])` `    ``# Sort the Array B[]``    ``B.sort()``    ``pq.sort(reverse ``=` `True``)` `    ``# Traverse the array B[]``    ``for` `i ``in` `range``(N):``      ` `        ``# Pop minimum element``        ``minn ``=` `pq.pop()``        ` `        ``# Check which operation is``        ``# producing maximum element``        ``maximized_element ``=` `max``(minn ``*` `B[i], minn ``+` `B[i])``        ` `        ``# Insert resultant element``        ``# into the priority queue``        ``pq.append(maximized_element)``        ``pq.sort(reverse ``=` `True``)``        ` `    ``# Evaluate the product``    ``# of the elements of A[]``    ``max_product ``=` `1``    ``while``(``len``(pq) > ``0``):``        ``max_product ``*``=` `pq.pop();``    ` `    ``# Return the maximum product   ``    ``return` `max_product` `# Driver Code` `# Given arrays``A ``=` `[``1``, ``1``, ``10``]``B ``=` `[``1``, ``1``, ``1``]``N ``=` `3` `# Function Call``print``(largeProduct(A, B, N))` `# This code is contributed by avanitrachhadiya2155`

## C#

 `// C# program for the above approach``using` `System;``using` `System.Collections.Generic;``class` `GFG``{``  ` `    ``// Function to find the largest``    ``// product of array A[]``    ``public` `static` `int` `largeProduct(``int``[] A, ``int``[] B, ``int` `N)``    ``{``      ` `        ``// Base Case``        ``if``(N == 0)``        ``{``            ``return` `0;``        ``}``      ` `        ``// Store all the elements of``        ``// the array A[]``        ``List<``int``> pq = ``new` `List<``int``>();``        ``for``(``int` `i = 0; i < N; i++)``        ``{``            ``pq.Add(A[i]);``        ``}``      ` `        ``// Sort the Array B[]``        ``Array.Sort(B);``        ``pq.Sort();``      ` `        ``// Traverse the array B[]``        ``for``(``int` `i = 0; i < N; i++)``        ``{``            ``int` `min = pq;``          ` `            ``// Pop minimum element``            ``pq.RemoveAt(0);``          ` `            ``// Check which operation is``            ``// producing maximum element``            ``int` `maximized_element = Math.Max(min* B[i], min + B[i]);``          ` `            ``// Insert resultant element``            ``// into the priority queue``            ``pq.Add(maximized_element);``            ``pq.Sort();``        ``}``      ` `        ``// Evaluate the product``        ``// of the elements of A[]``        ``int` `max_product = 1;``        ``while``(pq.Count > 0)``        ``{``            ``max_product *= pq;``            ``pq.RemoveAt(0);``        ``}``      ` `        ``// Return the maximum product``        ``return` `max_product;``    ``}``  ` `    ``// Driver Code``    ``static` `public` `void` `Main ()``    ``{``      ` `        ``// Given arrays``        ``int``[] A = { 1, 1, 10 };``        ``int``[] B = { 1, 1, 1 };``        ``int` `N = 3;``      ` `        ``// Function Call``        ``Console.WriteLine(largeProduct(A, B, N));``    ``}``}` `// This code is contributed by rag2127`

## Javascript

 ``
Output:
`60`

Time Complexity: O(N log N)
Auxiliary Space: O(N)

My Personal Notes arrow_drop_up