多个列表的最佳组合，每个列表只选择一个值

Question

I've multiple lists and would like to find the best combination by picking only 1 value from each list. The best combination is where the total value is the highest. eg:

In the table below the idea combination would be event 1 from person 2, event 2 from person 3 and event 3 from person 1. Please note that this is an example and that the number of 'events' and 'persons' may vary.

Person	Event 1	Event 2	Event 3
Person 1	5	2	6
Person 2	10	3	6
Person 3	1	7	2

The best combination would be:

• Person 1: Event 3 (6)
• Person 2: Event 1 (10)
• Person 3: Event 2 (7)

I first thought that this could be achieved with the Cartesian Product. For more details see https://en.wikipedia.org/wiki/Cartesian_product . However that will only sum all combination and don't take the 'pick-only-one-value-from-each-list' into account.

private static List<Integer> listOfPerson1 = List.of(5, 2, 6);
private static List<Integer> listOfPerson2 = List.of(10, 3, 6);
private static List<Integer> listOfPerson3 = List.of(1, 7, 2);


public static void main(String[] args) {
    List<List<Integer>> listOfPersons = new ArrayList<>();
    listOfPersons.add(listOfPerson1);
    listOfPersons.add(listOfPerson2);
    listOfPersons.add(listOfPerson3);

    List<Integer> result = new ArrayList<>();
    generatePermutations(listOfPersons, result, 0, 0);

    for (Integer i : result) {
        System.out.println(i);
    }
}

static void generatePermutations(List<List<Integer>> lists, List<Integer> result, int depth, Integer current) {
    if (depth == lists.size()) {
        result.add(current);
        return;
    }

    for (int i = 0; i < lists.get(depth).size(); i++) {
        generatePermutations(lists, result, depth + 1, current + lists.get(depth).get(i));
    }
}

Any idea how this can be achieved or what the name of such algorithm/mathematics is?

Answer 1

This problem is actually called the Assignment Problem which involves assigning agents to tasks in a way that optimises the total cost incurred.

In terms of algorithms to solve it, the one that I have seen used the most is the Hungarian Algorithm (also the pioneering algorithm for this problem) which has polynomial time complexity.