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:68Explanation:

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:800Explanation:

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^{2}) **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:- Choose at most
**X[i]**number of minimum element from the priority queue. - Replace it with
**Y[i]**if choose element is less than Y[i]. - Insert back the replaced element into the priority queue with their corresponding frequency.

- Choose at most
- 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++

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

*filter_none*

## Java

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

*filter_none*

**Output:**

800

**Time Complexity:** O(N*log_{2}N) **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.

## Recommended Posts:

- Maximum Possible Product in Array after performing given Operations
- Maximum score possible after performing given operations on an Array
- Maximum sum of all elements of array after performing given operations
- Maximum possible array sum after performing the given operation
- Maximum count of equal numbers in an array after performing given operations
- Maximum number of unique values in the array after performing given operations
- Maximum count of values of S modulo M lying in a range [L, R] after performing given operations on the array
- Minimum possible sum of array elements after performing the given operation
- Minimum possible sum of array elements after performing the given operation
- Maximum inversions in a sequence of 1 to N after performing given operations at most K times
- Minimum element left from the array after performing given operations
- Find the modified array after performing k operations of given type
- Number of elements from the array which are reachable after performing given operations on D
- Find the final sequence of the array after performing given operations
- Find the number on the card that remains in the end after performing the given operations
- Number of array elements derivable from D after performing certain operations
- Maximum value obtained by performing given operations in an Array
- Maximum possible sum after M operations on N cards
- Sum of the updated array after performing the given operation
- Maximum Subset Sum possible by negating the entire sum after selecting the first Array element

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.