Рекурсивная функция для получения комбинаций динамического номера List

Question

Я пытаюсь написать рекурсивную функцию, чтобы получить все возможные комбинации из динамического номера List. Например, если у меня есть 3 списка

List 1 : {A,B}
List 2 : {B,C}
List 3 : {D}

Несмотря на то, что на выходе каждый элемент встречается однажды, я бы хотел сохранить вывод в структуре

List<List<List<elements>>>

Мой ожидаемый результат будет

L1 : A, L2 : B, L3 : D
L1 : A, L2 : C, L3 : D
L1 : B, L2 : B, L3 : D
L1 : B, L2 : C, L3 : D

Здесь номер списка может меняться динамически. Поэтому мне нужен динамический номер вложенного цикла для поиска комбинаций.

Вот что я пытаюсь. Просто игнорируй мой ужасный код.

public List<List<List<elements>>> combinations(int depth, List<List<elements>> allLists,List<List<List<elements>>> answerList){

if(depth==allList.size())
 return answerList
 }
else{ 
 for(List<element> e : answerList){
    for(int j=0; j<e.size();j++){
      answerList.get(depth).get(j).add(allList.get(depth).get(j));
combinations (depth+1,allLists,answerList)
}
}
}

Пожалуйста, помогите мне, где я делаю неправильно?

EDIT:

моя идея - сохранить все комбинации вместе, чтобы

* ** 1 022 тысяча двадцать-один * {А}

будет самым глубоким списком в ответе

{L1, L2, L3}

будет вторым уровнем списка.

{L1, L2, L3}, {L1, L2, L3}

будет внешним списком. Таким образом, количество списков имеет значение здесь. все будет покрыто вышеуказанной структурой. мой окончательный вывод в приведенной выше структуре приведен ниже

 {
   {
     {A},
     {B},
     {D}
   },
   {
     {A},
     {C},
     {D}
   },
   {
     {B},
     {B},
     {D}
   },
   {
     {B},
     {C},
     {D}
   }
 }

Answer 1

Вам нужен довольно распространенный рекурсивный шаблон, в котором вы поддерживаете переменную, содержащую состояние, созданное до текущего уровня. Вот код для вас.

import java.util.Arrays;
import java.util.List;
import java.util.ArrayList;

public class Main 
{
  public static void recurse(int depth,
                      List<List<String>> current,
                      List<List<List<String>>> result,
                      List<List<String>> lists)
  {
    if (depth == lists.size()) {
      // Copy the list to the result
      result.add(new ArrayList<List<String>>(current));
      return;
    }
    // Iterate over the current-depth list
    List<String> list = lists.get(depth);
    for (String str: list) {
      List<String> elem = Arrays.asList(str);
      current.add(elem);   // Add the next element to the list
      recurse(depth + 1, current, result, lists);
      current.remove(depth);  // Clean up this element
    }
  }

  public static List<List<List<String>>> combinations(List<List<String>> allLists) 
  {
      // We'll fill it in
      List<List<List<String>>> result = new ArrayList<>();

      // Current, partial row in the final result
      List<List<String>> current = new ArrayList<>();

      recurse(0, current, result, allLists);

      return result;
  }

  public static void main(String[] args) {

    System.out.println("Hello World!");

    List<String> list1 = Arrays.asList("A", "B");
    List<String> list2 = Arrays.asList("B", "C", "E");
    List<String> list3 = Arrays.asList("D", "X");

    List<List<String>> allLists = Arrays.asList(list1, list2, list3);

    List<List<List<String>>> result = combinations(allLists);

    // Print
    for (List<List<String>> list: result) {
      System.out.print("{ ");
      for (List<String> elem: list)
        System.out.print("{" + elem.get(0) + "} ");
      System.out.println("}");
    }
  }
}

Кстати, вы можете немного упростить его без списков 3-го уровня, как предложено @dasblinkenlight