Related Articles

# Maximum sum by picking elements from two arrays in order

• Last Updated : 13 Dec, 2018

Given two arrays of size N and two integers X and Y indicating the maximum number of elements one can pick from array A and array B respectively.
At each ith turn, either A[i] or B[i] can be picked. The task is to make the selection that results in the maximum possible sum.
Note: It is guaranteed that (X + Y) ≥ N.

Examples:

Input: A[] = {1, 2, 3, 4, 5}, B[] = {5, 4, 3, 2, 1}, X = 3, Y = 2
Output: 21
i = 0 -> 5 picked
i = 1 -> 4 picked
i = 2 -> 3 picked
i = 3 -> 4 picked
i = 4 -> 5 picked
5 + 4 + 3 + 4 + 5 = 21

Input: A[] = {1, 4, 3, 2, 7, 5, 9, 6}, B[] = {1, 2, 3, 6, 5, 4, 9, 8}, X = 4, Y = 4
Output: 43

## Recommended: Please solve it on “PRACTICE” first, before moving on to the solution.

Approach: Use greedy approach to select the elements that will result in the maximum sum. Following steps will help in solving this problem:

• Sort the element pairs according to the absolute difference i.e. |A[i] – B[i]| in decreasing order.
• Compare A[i] and B[i] value, the one which is greater add that value to the sum.
• Decrement X by one if the element is chosen from A[i] else decrement Y by one.
• Print the sum in the end.

Below is the implementation of the above approach:

 `// Java program to calculate the``// maximum sum obtained by making an``// Optimal selection of elements from two given arrays`` ` `import` `java.io.*;``import` `java.util.*;``import` `java.lang.*;`` ` `// 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 comparator``class` `Compare {`` ` `    ``// Function to reverse the elements of an array``    ``static` `void` `reverseArray(Pair[] arr, ``int` `start, ``int` `end)``    ``{`` ` `        ``int` `tempx, tempy;``        ``while` `(start < end) {``            ``tempx = arr[start].x;``            ``tempy = arr[start].y;``            ``arr[start].x = arr[end].x;``            ``arr[start].y = arr[end].y;``            ``arr[end].x = tempx;``            ``arr[end].y = tempy;``            ``start++;``            ``end--;``        ``}``    ``}`` ` `    ``// Function to sort the pair according to the``    ``// absolute differences``    ``static` `Pair[] compare(Pair[] arr, ``int` `N)``    ``{`` ` `        ``// Comparator to sort the pair according to ``        ``// the absolute differences``        ``Arrays.sort(arr, ``new` `Comparator() {``            ``@Override``            ``public` `int` `compare(Pair p1, Pair p2)``            ``{``                ``return` `(Math.abs(p1.x - p1.y) - Math.abs(p2.x - p2.y));``            ``}``        ``});`` ` `        ``// To get in descending order``        ``reverseArray(arr, ``0``, N - ``1``);``        ``return` `arr;``    ``}``}`` ` `// Driver class``class` `GFG {`` ` `    ``// Function to calculate the``    ``// maximum possible sum obtained by making an``    ``// optimal selection elements from two given arrays`` ` `    ``static` `int` `getMaximumSum(``int``[] A, ``int``[] B, ``int` `N,``                                        ``int` `X, ``int` `Y)``    ``{``        ``int` `num1, num2, sum = ``0``;`` ` `        ``// Making a single pair array having``        ``// arr[i] element as (Ai, Bi)``        ``Pair[] arr = ``new` `Pair[N];``        ``for` `(``int` `i = ``0``; i < N; i++) {``            ``arr[i] = ``new` `Pair(A[i], B[i]);``        ``}`` ` `        ``// Sorting according to the absolute differences``        ``// in the decreasing order``        ``Compare obj = ``new` `Compare();``        ``obj.compare(arr, N);`` ` `        ``// Applying Greedy approach to make an optimal ``        ``// selection``        ``for` `(``int` `i = ``0``; i < N; i++) {``            ``num1 = arr[i].x;``            ``num2 = arr[i].y;`` ` `            ``// If A[i] > B[i]``            ``if` `(num1 > num2) {`` ` `                ``// If element from A can be picked``                ``if` `(X > ``0``) {``                    ``sum += num1;``                    ``X--;``                ``}`` ` `                ``// Insufficient X``                ``// Make a pick from B``                ``else` `if` `(Y > ``0``) {``                    ``sum += num2;``                    ``Y--;``                ``}``            ``}`` ` `            ``// If B[i] > A[i]``            ``else` `if` `(num2 > num1 && Y > ``0``) {`` ` `                ``// If element from B can be picked``                ``if` `(Y > ``0``) {``                    ``sum += num2;``                    ``Y--;``                ``}`` ` `                ``// Insufficient Y``                ``// Make a pick from A``                ``else` `{``                    ``sum += num1;``                    ``X--;``                ``}``            ``}`` ` `            ``// If A[i] = B[i]``            ``// Doesn't make a difference so any value ``            ``//  can be picked``            ``else` `{``                ``sum += num1;``                ``if` `(X > ``0``) {``                    ``X--;``                ``}``                ``else` `if` `(Y > ``0``)``                    ``Y--;``            ``}``        ``}``        ``return` `sum;``    ``}`` ` `    ``// Driver code``    ``public` `static` `void` `main(String args[])``    ``{``        ``int` `X = ``3``, Y = ``2``;``        ``int``[] A = { ``1``, ``2``, ``3``, ``4``, ``5` `};``        ``int``[] B = { ``5``, ``4``, ``3``, ``2``, ``1` `};``        ``int` `N = A.length;``        ``System.out.println(getMaximumSum(A, B, N, X, Y));``    ``}``}`
Output:
```21
```

My Personal Notes arrow_drop_up