GFG App
Open App
Browser
Continue

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

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.

Examples:

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

1. Update A[0] = A[0] + B[0], A[] modifies to {2, 1, 6}
2. Update A[1] = A[1] + B[1], A[] modifies to {2, 3, 6}
3. Update A[0] = A[0] * B[2], 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[0] = A[0] + B[0], A[] modifies to {2, 1, 10}
2. Update A[1] = A[1] + B[1], A[] modifies to {2, 2, 10}
3. Update A[0] = A[0] * B[2], 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[0];` `          `  `            ``// 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[0];` `            ``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