Maximum sum by picking elements from two arrays in order

// 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<Pair>() {
            @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));
    }
}

import java.util.*;

class Main {
    // Custom Comparator for min-heap based on the first element of the pair
    static class Compare implements Comparator<Pair<Integer, Integer>> {
        public int compare(Pair<Integer, Integer> a, Pair<Integer, Integer> b) {
            return Integer.compare(a.getKey(), b.getKey());
        }
    }

    public static int max_sum_4(List<Integer> A, List<Integer> B, int X, int Y) {
        PriorityQueue<Pair<Integer, Integer>> hA = new PriorityQueue<>(new Compare());
        PriorityQueue<Pair<Integer, Integer>> hB = new PriorityQueue<>(new Compare());

        for (int i = 0; i < A.size(); i++)
            hA.add(new Pair<>(-A.get(i), i));
        for (int j = 0; j < B.size(); j++)
            hB.add(new Pair<>(-B.get(j), j));

        int sum = 0;
        for (int i = 0; i < X; i++) {
            if (!hB.isEmpty() && -hA.peek().getKey() >= -hB.peek().getKey()) {
                sum += -hA.peek().getKey();
                hA.poll();
            } else {
                sum += -hB.peek().getKey();
                hB.poll();
            }
        }

        for (int j = 0; j < Y; j++) {
            if (!hA.isEmpty() && -hB.peek().getKey() >= -hA.peek().getKey()) {
                sum += -hB.peek().getKey();
                hB.poll();
            } else {
                sum += -hA.peek().getKey();
                hA.poll();
            }
        }

        return sum;
    }

    public static void main(String[] args) {
        List<Integer> A = Arrays.asList(1, 2, 3, 4, 5);
        List<Integer> B = Arrays.asList(5, 4, 3, 2, 1);
        int X = 3;
        int Y = 2;
        System.out.println(max_sum_4(A, B, X, Y)); // Output: 21
    }
}

// Simple Pair class implementation
class Pair<K, V> {
    private final K key;
    private final V value;

    public Pair(K key, V value) {
        this.key = key;
        this.value = value;
    }

    public K getKey() {
        return key;
    }

    public V getValue() {
        return value;
    }
}