Amazon | OA 2019 | 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]]

2-Pointers

Syntax side: Pay attention to how to print an array:   System.out.println(Arrays.toString(int[] item));

import java.util.*;
/**
 * https://leetcode.com/discuss/interview-question/373202
 */
public class OptimalUtilization {
    public List<int[]> optimal(List<int[]> a, List<int[]> b, int target) {
        if (a == null || a.isEmpty() || b == null || b.isEmpty()) {
            return new ArrayList<int[]>();
        }

        Collections.sort(a, (a1, a2) -> Integer.compare(a1[1], a2[1]));
        Collections.sort(b, (b1, b2) -> Integer.compare(b1[1], b2[1]));
        int m = a.size();
        int n = b.size();
        int i = 0;
        int j = n - 1;
        List<int[]> result = new ArrayList<>();
        int max = Integer.MIN_VALUE;
        while (i < m && j >= 0) {
            int sum = a.get(i)[1] + b.get(j)[1];
            if (sum <= target) {
                // maybe duplicate ele
                if (sum > max) {
                    result.clear();
                    max = sum;
                    result.add(new int[]{a.get(i)[0], b.get(j)[0]});
                } else if (sum == max) {
                    result.add(new int[]{a.get(i)[0], b.get(j)[0]});
                }
                i++;
            } else {
                j--;
            }
        }
        return result;
    }
    
    public static void main(String[] args) {
        OptimalUtilization sol = new OptimalUtilization();
        List<int[]> aa = new ArrayList<>();
        aa.add(new int[]{1, 8});
        aa.add(new int[]{2, 15});
        aa.add(new int[]{3, 9});
        List<int[]> bb = new ArrayList<>();
        bb.add(new int[]{1, 8});
        bb.add(new int[]{2, 11});
        bb.add(new int[]{3, 12});
        List<int[]> res = sol.optimal(aa, bb, 20);
        for (int[] item : res) {
            System.out.println(Arrays.toString(item));
        }
    }
}