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: (N2
Auxiliary Space: O(1)

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++

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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

chevron_right


Output: 

800

Time Complexity: O(N*log2N) 
Auxiliary Space: O(N) 

 

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.




My Personal Notes arrow_drop_up

Recommended Posts:


Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.



Improved By : offbeat