如何從 LinkedHashMap 的值進行組合<string, arraylist<arraylist> ></string,>

Question

假設我們有下面的 LinkedHashMap<String, ArrayList<ArrayList>>

    {FRA=[[1, 2], [3, 4]], MEL=[[5, 6]]}

output 應該是

    [1,2,5,6], [3,4,5,6]

同樣，如果輸入是：

    {SFO=[[1]], SEA=[[2], [3], [4]], PHX=[[5], [6]]}

然后預計 output 是

    [1,2,5],[1,2,6],[1,3,5],[1,3,6],[1,4,5],[1,4,6]

我試過下面的代碼，但沒有得到預期的結果。

    public static ArrayList<List<String>> getCombinations(ArrayList<ArrayList<String>> valueSetList) {
    int comboCount = 1;
    for (List<String> valueSet : valueSetList)
        comboCount = Math.multiplyExact(comboCount, valueSet.size()); // Fail if overflow
    ArrayList<List<String>> combinations = new ArrayList<>(comboCount);
    for (int comboNumber = 0; comboNumber < comboCount; comboNumber++) {
        List<String> combination = new ArrayList<>(valueSetList.size());
        int remain = comboNumber;
        for (List<String> valueSet : valueSetList) {
            combination.add(valueSet.get(remain % valueSet.size()));
            
            remain /= valueSet.size();
        }
        combinations.add(combination);
    }
    return combinations;
}

非常感謝任何幫助。

Answer 1

以下遞歸解決方案基於Philipp Meister對有關構建笛卡爾積的類似問題的回答：

static List<List<Integer>> merge(List<List<List<Integer>>> lists) {
    List<List<Integer>> resultLists = new ArrayList<>();
    if (lists.size() == 0) {
        resultLists.add(new ArrayList<>());
    } else {
        List<List<Integer>> firstList = lists.get(0);
        List<List<Integer>> remainingLists = merge(lists.subList(1, lists.size()));
        for (List<Integer> first : firstList) {
            for (List<Integer> remaining : remainingLists) {
                List<Integer> resultList = new ArrayList<>();
                resultList.addAll(first);
                resultList.addAll(remaining);
                resultLists.add(resultList);
            }
        }
    }
    return resultLists;
}  

主要區別在於返回類型和根據要求將first列表的所有元素添加到嵌套列表中。

測試設置

private static void testCombinations(Map<String, List<List<Integer>>> map) {
    System.out.println("input map: " + map);
    
    List<List<Integer>> list = merge(new ArrayList<>(map.values()));
    
    list.forEach(System.out::println);
}

// --------
Map<String, List<List<Integer>>> map1 = new LinkedHashMap<>();

map1.put("SFO", Arrays.asList(Arrays.asList(1)));
map1.put("SEA", Arrays.asList(Arrays.asList(2), Arrays.asList(3), Arrays.asList(4)));
map1.put("PHX", Arrays.asList(Arrays.asList(5), Arrays.asList(6)));

testCombinations(map1);
        
Map<String, List<List<Integer>>> map2 = new LinkedHashMap<>();

map2.put("FRA", Arrays.asList(Arrays.asList(1, 2), Arrays.asList(3, 4)));
map2.put("MEL", Arrays.asList(Arrays.asList(5, 6)));
testCombinations(map2);

Output：

input map: {SFO=[[1]], SEA=[[2], [3], [4]], PHX=[[5], [6]]}
[1, 2, 5]
[1, 2, 6]
[1, 3, 5]
[1, 3, 6]
[1, 4, 5]
[1, 4, 6]
input map: {FRA=[[1, 2], [3, 4]], MEL=[[5, 6]]}
[1, 2, 5, 6]
[3, 4, 5, 6]

---

該解決方案可以使用流和遞歸flatMap鏈來實現（基於Marco13 的回答）：

static <T extends List> Stream<List<T>> ofCombinations(List<? extends Collection<T>> mapValues, List<T> current) {
    return mapValues.isEmpty() ? Stream.of(current) :
        mapValues.get(0).stream().flatMap(list -> {
            List<T> combination = new ArrayList<T>(current);
            combination.addAll(list);
            return ofCombinations(mapValues.subList(1, mapValues.size()), combination);
        });
}

private static void testStreamCombinations(Map<String, List<List<Integer>>> map) {
    System.out.println("input map: " + map);
    
    ofCombinations(new ArrayList<>(map.values()), Collections.emptyList())
        .forEach(System.out::println);   
}

// invoking test method
testStreamCombinations(map1);
testStreamCombinations(map2);

測試output：同上。