Maximum possible Array sum after performing given operations

Given array arr[] of positive integers, an integer Q, and arrays X[] and Y[] of size Q. For each element in arrays X[] and Y[], we can perform the below operations:

• For each query from array X[] and Y[], select at most X[i] elements from array arr[] and replace all the selected elements with integer Y[i].
• After performing Q operations, the task is to obtain maximum sum from the array arr[].

Examples:

Input: arr[] = {5, 2, 6, 3, 8, 5, 4, 7, 9, 10}, Q = 3, X[] = {2, 4, 1}, Y[] = {4, 3, 10} 
Output: 68 
Explanation: 
For i = 1, 
We can replace atmost 2 elements from array arr[] with integer 4. Here 2 element of array arr[] are smaller than 4 so we will replace elements 2 and 3 from array arr[] with 4 and arr[] becomes {5, 4, 6, 4, 8, 5, 4, 7, 9, 10}.
For i = 2, 
We can replace at most 4 elements from array ar[] with integer 3, but no element of array arr[] is smaller than 3. So we will not replace anything.
For i = 3, 
We can replace at most 1 element from array arr[] with integer 10, 9 elements of array arr[] are smaller than 10. To get the maximum sum, we will replace the smallest element from array arr[] with 10. Array arr[] after 3rd operation = {5, 10, 6, 4, 8, 5, 10, 7, 9, 10 }. The maximum possible sum is 68.
Input: ar[] = {200, 100, 200, 300}, Q = 2, X[] = {2, 3}, Y[] = {100, 90} 
Output: 800 
Explanation: 
For i = 1, 
We can replace atmost 2 elements from array arr[] with integer 100, no element of array arr[] is smaller than 100. So we will replace 0 elements.
For i = 2, 
We can replace at most 3 elements from array arr[] with integer 90, no element of array arr[] is smaller than 90. So we will replace 0 elements. So the maximum sum we can obtain after q operation is 800.

Naive Approach: The naive idea is to pick X[i] number elements from the array arr[]. If the elements in the array are less than Y[i] then update X[i] of such elements. 
Time Complexity: (N²), as we will be using nested loops for traversing N*N times. Where N is the number of elements in the array.
Auxiliary Space: O(1), as we will not be using any extra space.

Efficient Approach: The idea is to use a priority queue to get the element with higher value before the element with lower value, precisely priority queue of pairs to store value with its frequency. Below are the steps:

• Insert each element of the array arr[] with their occurrence in the priority queue.
• For each element(say X[i]) in the array X[] do the following: 
  
  1. Choose at most X[i] number of minimum element from the priority queue.
  2. Replace it with Y[i] if choose element is less than Y[i].
  3. Insert back the replaced element into the priority queue with their corresponding frequency.
• After the above operations the array arr[] will have elements such that sum of all element is maximum. Print the sum.

Below is the implementation of the above approach:

// C++ implementation to find the
// maximum possible sum of array
// after performing given operations
#include <bits/stdc++.h>
using namespace std;

// Function to get maximum
// sum after q operations
void max_sum(int ar[], int n,
             int q, int x[], int y[])
{
    int ans = 0, i;

    // priority queue to
    // get maximum sum
    priority_queue<pair<int, int> > pq;

    // Push pair, value and 1
    // in the priority queue
    for (i = 0; i < n; i++)
        pq.push({ ar[i], 1 });

    // Push pair, value (to be replaced)
    // and number of elements (to be replaced)
    for (i = 0; i < q; i++)
        pq.push({ y[i], x[i] });

    // Add top n elements from
    // the priority queue
    // to get max sum
    while (n > 0) {

        // pr is the pair
        // pr.first is the value and
        // pr.second is the occurrence
        auto pr = pq.top();

        // pop from the priority queue
        pq.pop();

        // Add value to answer
        ans += pr.first * min(n, pr.second);

        // Update n
        n -= pr.second;
    }

    cout << ans << "\n";
}

// Driver code
int main()
{
    int ar[] = { 200, 100, 200, 300 };
    int n = (sizeof ar) / (sizeof ar[0]);
    int q = 2;
    int x[] = { 2, 3 };
    int y[] = { 100, 90 };
    max_sum(ar, n, q, x, y);

    return 0;
}

// Java implementation to find the 
// maximum possible sum of array 
// after performing given operations 
import java.util.*;
import java.lang.*;

class GFG{

static class pair
{
    int first, second;
    pair(int first, int second)
    {
        this.first = first;
        this.second = second;
    }
}

// Function to get maximum 
// sum after q operations 
static void max_sum(int ar[], int n, int q,
                    int x[], int y[]) 
{ 
    int ans = 0, i; 

    // priority queue to 
    // get maximum sum 
    PriorityQueue<pair> pq = new PriorityQueue<>(
        (a, b) -> Integer.compare(a.second, b.second)); 

    // Push pair, value and 1 
    // in the priority queue 
    for(i = 0; i < n; i++) 
        pq.add(new pair(ar[i], 1 )); 

    // Push pair, value (to be replaced) 
    // and number of elements (to be replaced) 
    for(i = 0; i < q; i++) 
        pq.add(new pair(y[i], x[i])); 

    // Add top n elements from 
    // the priority queue 
    // to get max sum 
    while (n > 0)
    { 
        
        // pr is the pair 
        // pr.first is the value and 
        // pr.second is the occurrence 
        pair pr = pq.peek(); 

        // pop from the priority queue 
        pq.poll(); 

        // Add value to answer 
        ans += pr.first * Math.min(n, pr.second); 

        // Update n 
        n -= pr.second; 
    } 
    System.out.println(ans); 
} 

// Driver Code
public static void main (String[] args)
{
    int ar[] = { 200, 100, 200, 300 }; 
    int n = ar.length; 
    int q = 2; 
    int x[] = { 2, 3 }; 
    int y[] = { 100, 90 };
    
    max_sum(ar, n, q, x, y); 
}
}

// This code is contributed by offbeat

# Python implementation to find the
# maximum possible sum of array
# after performing given operations

from queue import PriorityQueue


def max_sum(arr, n, q, x, y):
    ans = 0
    i = 0
    #  priority queue to
    #  get maximum sum
    pq = PriorityQueue()
    # Push pair, value and 1
    # in the priority queue
    for i in range(n):
        pq.put((-arr[i], 1))

    # Push pair, value (to be replaced)
    # and number of elements (to be replaced)
    for i in range(q):
        pq.put((-y[i], x[i]))

    # Add top n elements from
    # the priority queue
    # to get max sum

    while n > 0:
        # pr is the pair
        # pr.first is the value and
        # pr.second is the occurrence
        pr = pq.get()
        # Add value to answer
        ans += abs(pr[0]) * min(n, pr[1])
        # Update n
        n -= pr[1]
    print(ans)


ar = [200, 100, 200, 300]
n = len(ar)
q = 2
x = [2, 3]
y = [100, 90]
max_sum(ar, n, q, x, y)

# This code is provided by sdeadityasharma

// C# implementation to find the
// maximum possible sum of array
// after performing given operations
using System;
using System.Linq;
using System.Collections.Generic;

public class Pair {
  public int first;
  public int second;
  public Pair(int first, int second)
  {
    this.first = first;
    this.second = second;
  }
}

public class GFG {

  // Function to get maximum
  // sum after q operations
  static void MaxSum(int[] ar, int n, int q, int[] x,
                     int[] y)
  {
    int ans = 0;
    int i, j;

    // Push pair, value and 1
    // in the array
    List<Pair> pq = new List<Pair>();
    for (i = 0; i < n; i++)
      pq.Add(new Pair(ar[i], 1));

    // Push pair, value (to be replaced)
    // and number of elements (to be replaced)
    for (i = 0; i < q; i++)
      pq.Add(new Pair(y[i], x[i]));

    pq = pq.OrderBy(p => p.second).ToList();

    // Add top n elements from
    // the priority queue
    // to get max sum
    while (n > 0) {

      // pr is the pair
      // pr.first is the value and
      // pr.second is the occurrence
      var pr = pq[0];

      // pop from the priority queue
      pq.RemoveAt(0);

      // Add value to answer
      ans += pr.first * Math.Min(n, pr.second);

      // Update n
      n -= pr.second;
    }
    Console.WriteLine(ans);
  }

  // Driver Code
  public static void Main(string[] args)
  {
    int[] ar = { 200, 100, 200, 300 };
    int n = ar.Length;
    int q = 2;
    int[] x = { 2, 3 };
    int[] y = { 100, 90 };

    MaxSum(ar, n, q, x, y);
  }
}

// This code is contributed by phasing17

    // Javascript implementation to find the
    // maximum possible sum of array
    // after performing given operations
    
    // Function to get maximum
    // sum after q operations
        function max_sum(arr, n, q, x, y) {
        let ans = 0;
        
         // priority queue to
        // get maximum sum
        let pq = [];
          
         // Push pair, value and 1
        // in the priority queue
        for (let i = 0; i < n; i++) {
            pq.push([-arr[i], 1]);
        }
        
        // Push pair, value (to be replaced)
        // and number of elements (to be replaced)
        for (let i = 0; i < q; i++) {
            pq.push([-y[i], x[i]]);
        }
        pq.sort((a, b) => a[0] - b[0]);
        
        // Add top n elements from
        // the priority queue
        // to get max sum
        while (n > 0)
        {
        
            // pr is the pair
            // pr.first is the value and
            // pr.second is the occurrence
            let pr = pq.shift();
            
            // Add value to answer
            ans += Math.abs(pr[0]) * Math.min(n, pr[1]);
            
            // Update n
            n -= pr[1];
        }
          
        console.log(ans);
        }
        
        // Driver code
        let ar = [200, 100, 200, 300];
        let n = ar.length;
        let q = 2;
        let x = [2, 3];
        let y = [100, 90];
        
        max_sum(ar, n, q, x, y);
        
        // This code is contributed by Aman Kumar.

800

Time Complexity: O(N*log₂N), as we are using a loop to traverse N times and priority queue operation will take log₂N times. Where N is the number of elements in the array.
Auxiliary Space: O(N), as we are using extra space for the priority queue. Where N is the number of elements in the array.