[Algo] Optimal Utilization

Given 2 lists a and b. Each element is a pair of integers where the first integer represents the unique id and the second integer represents a value. Your task is to find an element from a and an element form b such that the sum of their values is less or equal to target and as close to target as possible. Return a list of ids of selected elements. If no pair is possible, return an empty list.

Example 1:

Input:
a = [[1, 2], [2, 4], [3, 6]]
b = [[1, 2]]
target = 7

Output: [[2, 1]]

Explanation:
There are only three combinations [1, 1], [2, 1], and [3, 1], which have a total sum of 4, 6 and 8, respectively.
Since 6 is the largest sum that does not exceed 7, [2, 1] is the optimal pair.

Example 2:

Input:
a = [[1, 3], [2, 5], [3, 7], [4, 10]]
b = [[1, 2], [2, 3], [3, 4], [4, 5]]
target = 10

Output: [[2, 4], [3, 2]]

Explanation:
There are two pairs possible. Element with id = 2 from the list `a` has a value 5, and element with id = 4 from the list `b` also has a value 5.
Combined, they add up to 10. Similarily, element with id = 3 from `a` has a value 7, and element with id = 2 from `b` has a value 3.
These also add up to 10. Therefore, the optimal pairs are [2, 4] and [3, 2].

Example 3:

Input:
a = [[1, 8], [2, 7], [3, 14]]
b = [[1, 5], [2, 10], [3, 14]]
target = 20

Output: [[3, 1]]

Example 4:

Input:
a = [[1, 8], [2, 15], [3, 9]]
b = [[1, 8], [2, 11], [3, 12]]
target = 20

Output: [[1, 3], [3, 2]]

    public static List<int[]> getOptimal(List<int[]> aList, List<int[]> bList, int target) {
        List<int[]> res = new ArrayList<>();
        int max = Integer.MIN_VALUE;
        Collections.sort(aList, ((a, b) -> a[1] - b[1]));
        Collections.sort(bList, ((a, b) -> a[1] - b[1]));
        int i = 0, j = bList.size() - 1;
        for (int[] arr : bList) {
            System.out.print(Arrays.toString(arr));
        }
        while (i < aList.size() && j >= 0) {
            int sum = aList.get(i)[1] + bList.get(j)[1];
            if (sum > target) {
                j -= 1;
            } else {
                if (sum > max) {
                    // need to update sum
                    max = sum;
                    res.clear();
                }
                res.add(new int[] {aList.get(i)[0], bList.get(j)[0]});
                int index = j - 1;
                System.out.println("j: " + j);
                System.out.println("index: " + index);
                while (index >= 0 && bList.get(index)[1] == bList.get(index + 1)[1]) {
                    res.add(new int[] {aList.get(i)[0], bList.get(index)[0]});
                    index -= 1;
                }
                i += 1;
            }
        }
        return res;
    }