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 <bits/stdc++.h>
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<Integer> 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

<script>
// Javascript program for the above approach

// Function to find the largest
// product of array A[]
function  largeProduct(A, B, N)
{

    // Base Case
        if (N == 0)
            return 0;

        // Store all the elements of
        // the array A[]
        let pq=[];

        for (let i = 0; i < N; i++)
            pq.push(A[i]);
        pq.sort(function(a,b){return a-b;});

        // Sort the Array B[]
        B.sort(function(a,b){return a-b;});

        // Traverse the array B[]
        for (let i = 0; i < N; i++) {

            // Pop minimum element
            let minn = pq.shift();

            // Check which operation is
            // producing maximum element
            let maximized_element
                = Math.max(minn * B[i],
                           minn + B[i]);

            // Insert resultant element
            // into the priority queue
            pq.push(maximized_element);
            pq.sort(function(a,b){return a-b;});
        }

        // Evaluate the product
        // of the elements of A[]
        let max_product = 1;
        while (pq.length > 0) {

            max_product *= pq.shift();
        }

        // Return the maximum product
        return max_product;
}

// Driver Code
let A=[1, 1, 10 ];
let B=[1, 1, 1];
let N = 3;
document.write(largeProduct(A, B, N));

// This code is contributed by patel2127
</script>

Output:

60

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