• [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;
        }
  • 相关阅读:
    浅析 Java 中的 final 关键字
    谷歌Java编程风格指南
    分布式事务之两阶段提交协议(2PC)and 使用事件和消息队列实现分布式事务
    零和博弈与木桶定律
    Executors类创建四种常见线程池
    软件设计的原则&101个设计模式-2011年04月25日 陈皓
    编程中的命名设计那点事-陈皓
    从面向对象的设计模式看软件设计- 2013年02月01日 陈皓
    SQL语句
    分布式事务
  • 原文地址:https://www.cnblogs.com/xuanlu/p/12640374.html
Copyright © 2020-2023  润新知