Comment générer toutes les combinaisons possibles à partir de plusieurs listes en Java en utilisant la récursion ?

Générer toutes les combinaisons à partir de plusieurs listes en Java

Générer une seule liste contenant toutes les combinaisons uniques possibles à partir d'un nombre arbitraire de listes, chacune avec des longueurs variables, peut être un tâche difficile. Cet article explore une solution basée sur Java utilisant le concept de récursion.

Énoncé du problème

Étant donné un nombre inconnu de listes, chacune avec une longueur inconnue, l'objectif est créer une liste unique comprenant toutes les combinaisons possibles d'éléments de ces listes. Par exemple, avec les listes X et Y définies comme :

X: [A, B, C] 
Y: [W, X, Y, Z]

Le résultat attendu serait une liste avec 12 combinaisons :

[AW, AX, AY, AZ, BW, BX, BY, BZ, CW, CX, CY, CZ]

Solution

La solution utilise la récursivité pour générer toutes les combinaisons possibles. Les listes sont stockées dans une liste de listes et une liste de résultats est créée pour contenir les permutations. La méthode generatePermutations prend en entrée la liste des listes, la liste des résultats, un paramètre de profondeur et une chaîne qui représente la permutation actuelle.

Méthode generatePermutations

<code class="java">void generatePermutations(List<List<Character>> lists, List<String> result, int depth, String current) {
    // Base case: if we've reached the end of the list of lists
    if (depth == lists.size()) {
        result.add(current);
        return;
    }

    // Get the current list at the specified depth
    List<Character> currentList = lists.get(depth);

    // Iterate over each element in the current list
    for (int i = 0; i < currentList.size(); i++) {
        // Recursively call generatePermutations to build permutations
        generatePermutations(lists, result, depth + 1, current + currentList.get(i));
    }
}</code>

L'appel initial à la méthode generatePermutations définira la profondeur sur 0 et la chaîne actuelle sur une chaîne vide. Chaque appel récursif incrémentera la profondeur et concatènera le caractère actuel à la chaîne actuelle. Le cas de base est atteint lorsque la profondeur est égale au nombre de listes, et à ce stade, la permutation actuelle est ajoutée à la liste de résultats.

En utilisant la récursivité, la méthode generatePermutations construit efficacement toutes les combinaisons possibles de éléments des listes d’entrée et les ajoute à la liste de résultats. Cette solution est efficace et adaptable à n'importe quel nombre ou longueur de listes de saisie.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!