Related Articles

# Maximize the sum of X+Y elements by picking X and Y elements from 1st and 2nd array

• Difficulty Level : Medium
• Last Updated : 30 Mar, 2021

Given two arrays of size N, and two numbers X and Y, the task is to maximize the sum by considering the below points:

• Pick x values from the first array and y values from the second array such that the sum of X+Y values is maximum.
• It is given that X + Y is equal to N.

Examples:

Input: arr1[] = {1, 4, 1}, arr2[] = {2, 5, 3}, N = 3, X = 2, Y = 1
Output:
In order to maximize sum from 2 arrays,
pick 1st and 2nd element from first array and 3rd from second array.

Input: A[] = {1, 4, 1, 2}, B[] = {4, 3, 2, 5}, N = 4, X = 2, Y = 2
Output: 14

Approach: A greedy approach can be used to solve the above problem. Below are the required steps:

• Find those elements of arrays first that have maximum value by finding the highest difference between elements of two arrays.
• For that, find the absolute difference between the value of the first and second array and then store it in some another array.
• Sort this array in decreasing order.
• While sorting, track the original positions of elements in the arrays.
• Now compare the elements of the two arrays and add the greater value to the maxAmount.
• If both have the same value, add an element of the first array if X is not zero else add an element of the second array.
• After traversing the arrays completely return the maxAmount calculated.

Below is the implementation of above approach :

## C++

 `// C++ program to print the maximum``// possible sum from two arrays.``#include ``using` `namespace` `std;` `// class that store values of two arrays``// and also store their absolute difference``class` `triplet {``public``:``    ``int` `first;``    ``int` `second;``    ``int` `diff;``    ``triplet(``int` `f, ``int` `s, ``int` `d)``        ``: first(f), second(s), diff(d)``    ``{``    ``}``};` `// Compare function used to sort array in decreasing order``bool` `compare(triplet& a, triplet& b)``{``    ``return` `a.diff > b.diff; ``// decreasing order``}` `/// Function to find the maximum possible``/// sum that can be generated from 2 arrays``int` `findMaxAmount(``int` `arr1[], ``int` `arr2[], ``int` `n, ``int` `x, ``int` `y)``{``    ``// vector where each index stores 3 things:``    ``// Value of 1st array``    ``// Value of 2nd array``    ``// Their absolute difference``    ``vector v;` `    ``for` `(``int` `i = 0; i < n; i++) {``        ``triplet t(arr1[i], arr2[i], ``abs``(arr1[i] - arr2[i]));``        ``v.push_back(t);``    ``}` `    ``// sort according to their absolute difference``    ``sort(v.begin(), v.end(), compare);` `    ``// it will store maximum sum``    ``int` `maxAmount = 0;` `    ``int` `i = 0;` `    ``// Run loop for N times or``    ``// value of X or Y becomes zero``    ``while` `(i < n && x > 0 && y > 0) {` `        ``// if 1st array element has greater``        ``// value, add it to maxAmount``        ``if` `(v[i].first > v[i].second) {``            ``maxAmount += v[i].first;``            ``x--;``        ``}` `        ``// if 2nd array element has greater``        ``// value, add it to maxAmount``        ``if` `(v[i].first < v[i].second) {``            ``maxAmount += v[i].second;``            ``y--;``        ``}` `        ``// if both have same value, add element``        ``// of first array if X is not zero``        ``// else add element of second array``        ``if` `(v[i].first == v[i].second) {``            ``if` `(x > 0) {``                ``maxAmount += v[i].first;``                ``x--;``            ``}``            ``else` `if` `(y > 0) {``                ``maxAmount += v[i].second;``                ``y--;``            ``}``        ``}` `        ``// increment after picking element``        ``i++;``    ``}` `    ``// add the remaining values``    ``// of first array to maxAmount``    ``while` `(i < v.size() && x--) {``        ``maxAmount += v[i++].first;``    ``}` `    ``// add the remaining values of``    ``// second array to maxAmount``    ``while` `(i < v.size() && y--) {``        ``maxAmount += v[i++].second;``    ``}` `    ``return` `maxAmount;``}` `// Driver Code``int` `main()``{``    ``int` `A[] = { 1, 4, 1, 2 };``    ``int` `B[] = { 4, 3, 2, 5 };``    ``int` `n = ``sizeof``(A) / ``sizeof``(A);` `    ``int` `X = 2, Y = 2;` `    ``cout << findMaxAmount(A, B, n, X, Y) << ``"\n"``;``}`

## Java

 `// Java program to print the maximum``// possible sum from two arrays.``import` `java.util.*;` `// class that store values of two arrays``// and also store their absolute difference``class` `Triplet ``implements` `Comparable``{``    ``int` `first;``    ``int` `second;``    ``int` `diff;` `    ``Triplet(``int` `f, ``int` `s, ``int` `d)``    ``{``        ``first = f;``        ``second = s;``        ``diff = d;``    ``}``    ` `    ``// CompareTo function used to sort``    ``// array in decreasing order``    ``public` `int` `compareTo(Triplet o)``    ``{``        ``return` `o.diff - ``this``.diff;``    ``}``}``class` `GFG{` `// Function to find the maximum possible``// sum that can be generated from 2 arrays``public` `static` `int` `findMaxAmount(``int` `arr1[],``                                ``int` `arr2[],``                                ``int` `n, ``int` `x,``                                ``int` `y)``{``    ` `    ``// Vector where each index``    ``// stores 3 things:``    ``// Value of 1st array``    ``// Value of 2nd array``    ``// Their absolute difference``    ``Vector v = ``new` `Vector<>();` `    ``for``(``int` `i = ``0``; i < n; i++)``    ``{``       ``v.add(``new` `Triplet(arr1[i], arr2[i],``                         ``Math.abs(arr1[i] -``                                  ``arr2[i])));``    ``}` `    ``// Sort according to their``    ``// absolute difference``    ``Collections.sort(v);` `    ``// It will store maximum sum``    ``int` `maxAmount = ``0``;` `    ``int` `i = ``0``;` `    ``// Run loop for N times or``    ``// value of X or Y becomes zero``    ``while` `(i < n && x > ``0` `&& y > ``0``)``    ``{``        ` `        ``// If 1st array element has greater``        ``// value, add it to maxAmount``        ``if` `(v.get(i).first > v.get(i).second)``        ``{``            ``maxAmount += v.get(i).first;``            ``x--;``        ``}` `        ``// If 2nd array element has greater``        ``// value, add it to maxAmount``        ``if` `(v.get(i).first < v.get(i).second)``        ``{``            ``maxAmount += v.get(i).second;``            ``y--;``        ``}``    ` `        ``// If both have same value, add element``        ``// of first array if X is not zero``        ``// else add element of second array``        ``if` `(v.get(i).first == v.get(i).second)``        ``{``            ``if` `(x > ``0``)``            ``{``                ``maxAmount += v.get(i).first;``                ``x--;``            ``}``            ``else` `if` `(y > ``0``)``            ``{``                ``maxAmount += v.get(i).second;``                ``y--;``            ``}``        ``}``        ` `        ``// Increment after picking element``        ``i++;``    ``}` `    ``// Add the remaining values``    ``// of first array to maxAmount``    ``while` `(i < v.size() && x-- > ``0``)``    ``{``        ``maxAmount += v.get(i++).first;``    ``}` `    ``// Add the remaining values of``    ``// second array to maxAmount``    ``while` `(i < v.size() && y-- > ``0``)``    ``{``        ``maxAmount += v.get(i++).second;``    ``}``    ` `    ``return` `maxAmount;``}` `// Driver Code``public` `static` `void` `main(String []args)``{``    ``int` `A[] = { ``1``, ``4``, ``1``, ``2` `};``    ``int` `B[] = { ``4``, ``3``, ``2``, ``5` `};``    ``int` `n = A.length;` `    ``int` `X = ``2``, Y = ``2``;` `    ``System.out.println(findMaxAmount(A, B, n, X, Y));``}``}` `// This code is contributed by jrishabh99`

## Python3

 `# Python3 program to print the maximum``# possible sum from two arrays.` `# Class that store values of two arrays``# and also store their absolute difference``class` `triplet:``    ` `    ``def` `__init__(``self``, f, s, d):``        ``self``.first ``=` `f``        ``self``.second ``=` `s``        ``self``.diff ``=` `d` `# Function to find the maximum possible``# sum that can be generated from 2 arrays``def` `findMaxAmount(arr1, arr2, n, x, y):` `    ``# vector where each index stores 3 things:``    ``# Value of 1st array``    ``# Value of 2nd array``    ``# Their absolute difference``    ``v ``=` `[]` `    ``for` `i ``in` `range``(``0``, n):``        ``t ``=` `triplet(arr1[i], arr2[i],``                ``abs``(arr1[i] ``-` `arr2[i]))``        ``v.append(t)` `    ``# sort according to their absolute difference``    ``v.sort(key ``=` `lambda` `x: x.diff, reverse ``=` `True``)` `    ``# it will store maximum sum``    ``maxAmount, i ``=` `0``, ``0` `    ``# Run loop for N times or``    ``# value of X or Y becomes zero``    ``while` `i < n ``and` `x > ``0` `and` `y > ``0``:` `        ``# if 1st array element has greater``        ``# value, add it to maxAmount``        ``if` `v[i].first > v[i].second:``            ``maxAmount ``+``=` `v[i].first``            ``x ``-``=` `1` `        ``# if 2nd array element has greater``        ``# value, add it to maxAmount``        ``if` `v[i].first < v[i].second:``            ``maxAmount ``+``=` `v[i].second``            ``y ``-``=` `1` `        ``# if both have same value, add element``        ``# of first array if X is not zero``        ``# else add element of second array``        ``if` `v[i].first ``=``=` `v[i].second:``            ``if` `x > ``0``:``                ``maxAmount ``+``=` `v[i].first``                ``x ``-``=` `1``            ` `            ``elif` `y > ``0``:``                ``maxAmount ``+``=` `v[i].second``                ``y ``-``=` `1` `        ``# increment after picking element``        ``i ``+``=` `1``    ` `    ``# add the remaining values``    ``# of first array to maxAmount``    ``while` `i < ``len``(v) ``and` `x > ``0``:``        ``maxAmount ``+``=` `v[i].first``        ``i, x ``=` `i ``+` `1``, x ``-` `1` `    ``# add the remaining values of``    ``# second array to maxAmount``    ``while` `i < ``len``(v) ``and` `y > ``0``:``        ``maxAmount ``+``=` `v[i].second``        ``i, y ``=` `i ``+` `1``, y ``-` `1``    ` `    ``return` `maxAmount` `# Driver Code``if` `__name__ ``=``=` `"__main__"``:` `    ``A ``=` `[``1``, ``4``, ``1``, ``2``]``    ``B ``=` `[``4``, ``3``, ``2``, ``5``]``    ``n ``=` `len``(A)` `    ``X, Y ``=` `2``, ``2` `    ``print``(findMaxAmount(A, B, n, X, Y))` `# This code is contributed by Rituraj Jain`
Output:
`14`

Time complexity: O(N log 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.  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 experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

My Personal Notes arrow_drop_up