Skip to content
Related Articles

Related Articles

Improve Article
Maximum possible sum after M operations on N cards
  • Last Updated : 03 Jun, 2021

Given an array arr[] of size N which represents the initial number on each card and given a two dimensional array B[][] of size M where M represents the number of operations that need to be performed. At each operation, choose at most B[j][0] cards (possibly zero) and replace the integer written on each chosen card with B[j][1]. The task is to find the maximum possible sum after M operations.

Examples:  

Input: arr[] = {5, 1, 4}, B[][] = {{2, 3}, {1, 5}} 
Output: 14 
Replacing 1 with 5 and the sum becomes 
5 + 5 + 4 = 14 which is the maximum possible.

Input: arr[] = {100, 100}, B[][] = {{2, 99}} 
Output: 200 

Approach: A greedy approach is applicable here. Sort the array arr[] in increasing order and sort the array B[][] in decreasing order of the number to be replaced. Then try to replace last non-replaced card of arr[] with one of the non-used cards of B[][]. Finally, print the maximized sum.



Below is the implementation of the above approach:  

C++




// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to return the maximum
// possible sum after M operations
int max_sum(int a[], int n, int b[][2], int m)
{
 
    // Sort the array a in
    // increasing order
    sort(a, a + n);
 
    // Place all replacable cards in B
    vector<pair<int, int> > B;
    for (int i = 0; i < m; i++)
        B.push_back({ b[i][1], b[i][0] });
 
    // Sort vector B in decreasing order
    sort(B.rbegin(), B.rend());
 
    // To store last unused card of a
    int left = 0;
 
    // Try to apply all m operations
    for (int i = 0; i < m; i++) {
        int x = B[i].first, y = B[i].second;
 
        // Try for all applicable cards
        for (int j = 0; j < y; j++) {
 
            // If current number on card is
            // less than applicable card
            if (a[left] < x) {
                a[left] = x;
                left++;
 
                if (left == n)
                    break;
            }
            else
                break;
        }
    }
 
    // To store the maximum
    // possible sum
    int ans = 0;
 
    // Calculate the maximum
    // possible sum
    for (int i = 0; i < n; i++)
        ans += a[i];
 
    // Return the required answer
    return ans;
}
 
// Driver code
int main()
{
    int a[] = { 5, 1, 4 };
    int n = sizeof(a) / sizeof(a[0]);
    int b[][2] = { { 2, 3 }, { 1, 5 } };
    int m = sizeof(b) / sizeof(b[0]);
 
    cout << max_sum(a, n, b, m);
 
    return 0;
}

Java




// Java implementation of the approach
import java.util.*;
 
// User defined Pair class
class Pair {
  int x;
  int y;
 
  // Constructor
  public Pair(int x, int y)
  {
    this.x = x;
    this.y = y;
  }
}
 
// class to define user defined conparator
class Sort {
 
  static void sort(Pair arr[], int n)
  {
    // Comparator to sort the pair according to second element
    Arrays.sort(arr, new Comparator<Pair>() {
      @Override public int compare(Pair p1, Pair p2)
      {
        return p1.x - p2.x;
      }
    });
  }
}
 
public class Main
{
  // Function to return the maximum
  // possible sum after M operations
  static int max_sum(int[] a, int n,
                     int[][] b, int m)
  {
 
    // Sort the array a in
    // increasing order
    Arrays.sort(a);
 
    // Place all replacable cards in B
    Pair B[] = new Pair[m];
 
    for(int i = 0; i < m; i++)
      B[i] = new Pair(b[i][1], b[i][0]);
 
    // Sort vector B in decreasing order
    Sort obj = new Sort();
    obj.sort(B, m);
 
    // To store last unused card of a
    int left = 0;
 
    // Try to apply all m operations
    for(int i = m-1; i >= 0; i--)
    {
      int x = B[i].x, y = B[i].y;
 
      // Try for all applicable cards
      for(int j = 0; j < y; j++)
      {
 
        // If current number on card is
        // less than applicable card
        if (a[left] < x)
        {
          a[left] = x;
          left++;
 
          if (left == n)
            break;
        }
        else
          break;
      }
    }
 
    // To store the maximum
    // possible sum
    int ans = 0;
 
    // Calculate the maximum
    // possible sum
    for(int i = 0; i < n; i++)
      ans += a[i];
 
    // Return the required answer
    return ans;
  }
 
  // Driver code
  public static void main(String[] args) {
    int[] a = { 5, 1, 4 };
    int n = a.length;
    int[][] b = { { 2, 3 }, { 1, 5 } };
    int m = 2;
 
    System.out.println(max_sum(a, n, b, m));
  }
}
 
// This code is contributed by divyesh072019.

Python3




# Python3 implementation of the approach
 
# Function to return the maximum
# possible sum after M operations
def max_sum(a, n, b, m) :
 
    # Sort the array a in
    # increasing order
    a.sort();
 
    # Place all replacable cards in B
    B = [];
    for i in range(m) :
        B.append([b[i][1], b[i][0]]);
 
    # Sort vector B in decreasing order
    B.sort(reverse = True)
 
    # To store last unused card of a
    left = 0;
 
    # Try to apply all m operations
    for i in range(m) :
        x = B[i][0];
        y = B[i][1];
 
        # Try for all applicable cards
        for j in range(y) :
 
            # If current number on card is
            # less than applicable card
            if (a[left] < x) :
                a[left] = x;
                left += 1;
 
                if (left == n) :
                    break;
            else :
                break;
 
    # To store the maximum
    # possible sum
    ans = 0;
 
    # Calculate the maximum
    # possible sum
    for i in range(n) :
        ans += a[i];
 
    # Return the required answer
    return ans;
 
# Driver code
if __name__ == "__main__" :
 
    a = [5, 1, 4];
    n = len(a);
    b = [[2, 3], [1, 5]];
    m = len(b);
 
    print(max_sum(a, n, b, m));
 
# This code is contributed by AnkitRai01

C#




// C# implementation of the approach
using System;
using System.Collections.Generic;
 
class GFG{
     
// Function to return the maximum
// possible sum after M operations
static int max_sum(int[] a, int n,
                   int[,] b, int m)
{
     
    // Sort the array a in
    // increasing order
    Array.Sort(a);
   
    // Place all replacable cards in B
    List<Tuple<int,
               int>> B = new List<Tuple<int,
                                        int>>();
    for(int i = 0; i < m; i++)
        B.Add(new Tuple<int, int>(b[i, 1], b[i, 0]));
   
    // Sort vector B in decreasing order
    B.Sort();
    B.Reverse();
   
    // To store last unused card of a
    int left = 0;
   
    // Try to apply all m operations
    for(int i = 0; i < m; i++)
    {
        int x = B[i].Item1, y = B[i].Item2;
   
        // Try for all applicable cards
        for(int j = 0; j < y; j++)
        {
             
            // If current number on card is
            // less than applicable card
            if (a[left] < x)
            {
                a[left] = x;
                left++;
   
                if (left == n)
                    break;
            }
            else
                break;
        }
    }
   
    // To store the maximum
    // possible sum
    int ans = 0;
   
    // Calculate the maximum
    // possible sum
    for(int i = 0; i < n; i++)
        ans += a[i];
   
    // Return the required answer
    return ans;
}
 
// Driver code
static void Main()
{
    int[] a = { 5, 1, 4 };
    int n = a.Length;
    int[,] b = { { 2, 3 }, { 1, 5 } };
    int m = 2;
     
    Console.WriteLine(max_sum(a, n, b, m));
}
}
 
// This code is contributed by divyeshrabadiya07

Javascript




<script>
 
// JavaScript implementation of the approach
 
 
// Function to return the maximum
// possible sum after M operations
function max_sum(a, n, b, m) {
 
    // Sort the array a in
    // increasing order
    a.sort();
 
    // Place all replacable cards in B
    let B = new Array();
    for (let i = 0; i < m; i++)
        B.push([b[i][1], b[i][0]]);
 
    // Sort vector B in decreasing order
    B.sort().reverse();
 
    // To store last unused card of a
    let left = 0;
 
    // Try to apply all m operations
    for (let i = 0; i < m; i++) {
        let x = B[i][0], y = B[i][1];
 
        // Try for all applicable cards
        for (let j = 0; j < y; j++) {
 
            // If current number on card is
            // less than applicable card
            if (a[left] < x) {
                a[left] = x;
                left++;
 
                if (left == n)
                    break;
            }
            else
                break;
        }
    }
 
    // To store the maximum
    // possible sum
    let ans = 0;
 
    // Calculate the maximum
    // possible sum
    for (let i = 0; i < n; i++)
        ans += a[i];
 
    // Return the required answer
    return ans;
}
 
// Driver code
 
let a = [5, 1, 4];
let n = a.length;
let b = [[2, 3], [1, 5]];
let m = b.length;
 
document.write(max_sum(a, n, b, m));
 
</script>
Output: 
14

 

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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with industry experts, please refer Geeks Classes Live 




My Personal Notes arrow_drop_up
Recommended Articles
Page :