función recursiva para obtener combinaciones de número dinámico de la lista

kumaran Ragunathan:

Estoy tratando de escribir una función recursiva para obtener toda combinación Posible a partir del número dinámico de la lista. Por ejemplo, si tengo 3 Listas

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

A pesar de que en la salida de cada elemento se produce una vez me gustaría mantener la salida en la estructura de

List<List<List<elements>>>

Mi salida esperada será

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

Aquí el número de lista puede cambiar dinámicamente. Así que necesito número dinámica de bucle anidado para encontrar combinaciones.

Aquí lo que estoy tratando. Simplemente ignorar mi código horrible.

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)
}
}
}

Por favor me ayude a donde estoy haciendo mal?

EDITAR:

mi idea es mantener todas las combinaciones juntos para que

{UN}

será la lista más profundo de respuesta

{L1, L2, L3}

será el segundo nivel de la lista.

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

será la lista fuera. Por lo que el número de listas doest importa aquí. todo será cubierto por la estructura anterior. mi salida final en la estructura anterior se da a continuación

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

Marcin Zukowski:

Es necesario un modelo recursivo bastante común, donde se mantiene una variable que contiene el estado construido hasta el nivel actual. Aquí hay algo de código para usted.

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("}");
    }
  }
}

Por cierto, puede simplificar un poco sin el nivel 3 de las listas, como sugirió @dasblinkenlight