Рекурсивная перестановка с перечислениями Mutliple

Question

Мне любопытно, как я могу выполнить свой метод permuteAndPrintValuesThreeLists_Iterative рекурсивно ... Я знаю базовую рекурсию для сортировки массивов и выполнения двоичных поисков, но я не могу понять, как сделать ее методом рекурсивным.

Причина, по которой я хочу использовать рекурсию, заключается в том, что я хочу иметь возможность добавлять более 3 списков, не меняя свой метод, добавляя еще один цикл.

Вопрос: Как написать метод permuteAndPrintValuesThreeLists как метод recursive?

Мой вывод должен быть:

1 1 10 10 100 100 
1 1 10 10 200 200 
1 1 10 10 300 300 
1 1 20 20 100 100 
1 1 20 20 200 200 
1 1 20 20 300 300 
2 2 10 10 100 100 
2 2 10 10 200 200 
2 2 10 10 300 300 
2 2 20 20 100 100 
2 2 20 20 200 200 
2 2 20 20 300 300 

Но:

1 1 10 10 100 100 
200 200 
300 300 
400 400 
20 20 100 100 
200 200 
300 300 
400 400 
3 3 10 10 100 100 
200 200 
300 300 
400 400 
20 20 100 100 
200 200 
300 300 
400 400 

---

final class Problem { 

    public static void main(String[] args) { 
    Problem p = new Problem(); 
    p.permuteAndPrintValuesThreeLists_Iterative(); 
    } 

    private static List<int[]> l1; 
    private static List<int[]> l2; 
    private static List<int[]> l3; 

    private Problem() { 
    l1 = new ArrayList<>(); 
    l1.add(new int[] { 1, 1 }); 
    l1.add(new int[] { 2, 2 }); 

    l2 = new ArrayList<>(); 
    l2.add(new int[] { 10, 10 }); 
    l2.add(new int[] { 20, 20 }); 

    l3 = new ArrayList<>(); 
    l3.add(new int[] { 100, 100 }); 
    l3.add(new int[] { 200, 200 }); 
    l3.add(new int[] { 300, 300 }); 
    } 

    private static void permuteAndPrintValuesThreeLists_Iterative() { 
    for (int i = 0; i < l1.size(); i++) { 
     for (int j = 0; j < l2.size(); j++) { 
     for (int k = 0; k < l3.size(); k++) { 
      printArray(l1.get(i)); 
      printArray(l2.get(j)); 
      printArray(l3.get(k)); 
      System.out.println(); 
     } 
     } 
    } 
    } 

    private static void printArray(int[] a) { 
    for (int i : a) { 
     System.out.println(i + " "); 
    } 
    } 

} 

До сих пор я знал, что мне нужно иметь список, содержащий 3 списков (в в моем случае я добавил HashMap). У меня также есть этот метод решения, который частично решает проблему

private static Map<Integer, List<int[]>> allLists = new HashMap<>(); 
private static void permuteAndPrintValuesThreeLists_Recursion(List<int[]> resultList, int mapIndex) { 
    if (mapIndex == allLists.size()) { 
     // Debug code 
     for (int[] arr : resultList) 
      for (int i = 0; i < arr.length; i++) 
       System.out.println(arr[i] + " "); 
     resultList.clear(); 
     System.out.println(); 
     return; 
    } 
    for (int i = 0; i < allLists.get(mapIndex).size(); i++) { 
     int[] tmpArray = allLists.get(mapIndex).get(i); 
     resultList.add(tmpArray); 
     permuteAndPrintValuesThreeLists_Recursion(resultList, mapIndex + 1); 
    } 
} 

Answer 1

Добавляя попробовать поймать блок, я получил вывод, что я напечатал в моем вопросе. Я использую set, чтобы добавить новые значения для перестановки.

Теперь, если я хочу четвертый список, этот метод все еще работает.

private static void solution_withRecursion(List<int[]> resultList, int mapIndex) { 
    if (mapIndex == allLists.size()) { 
     printListValues(resultList); 
     return; 
    } 
    for (int i = 0; i < allLists.get(mapIndex).size(); i++) { 
     int[] tmpArray = allLists.get(mapIndex).get(i); 
     try { 
      resultList.set(mapIndex, tmpArray); 
     } catch (IndexOutOfBoundsException e) { 
      resultList.add(tmpArray); 
     } 
     solution_withRecursion(resultList, mapIndex + 1); 
    } 
} 


private static void printListValues(List<int[]> list) { 
    for (int[] arr : list) { 
     for (int i : arr) { 
      System.out.print(i + " "); 
     } 
    } 
    System.out.println(); 
}