9
votes

Comment obtenir toutes les combinaisons de plusieurs liste

diffère de la solution sugedd ci-dessus en ce qu'un élément de liste ne peut apparaître qu'une seule fois pour chaque ligne.

Ceci est pour un système de réservation pour mon spa. Différents employés peuvent effectuer différents traitements. P>

J'ai une liste > code>. Ce sont des thérapeutes qui peuvent effectuer le traitement réservé. P>

Chaque liste (la réservation) contient un certain nombre d'entiers tels que ceci (ce sont des thérapeutes qui peuvent effectuer la réservation): P>

{1, 3, 6},  //Booking 1
{1, 2, 6},  //Booking 2
{1},        //Booking 3
{2,3}       //Booking 4


 Réservation 1: Thérapeute 6  Li>
 Réservation 2: Thérapeute 2  Li>
 Réservation 3: Thérapeute 1  Li>
 Réservation 4: Thérapeute 3  Li>
 ul>  J'espère que cela rend la question un peu plus claire.  p>  p>

9 commentaires

Et comment avez-vous trouvé ces deux combinaisons?

@Samihuutoniemi Eh bien, je ne peux voir d'autres, pouvez-vous?

Non, dans cette question, les chiffres peuvent être à plusieurs endroits. Donc, toutes les combinaisons seraient acceptables là-bas.

La question n'a pas de sens. La solution semble être résolvable par distincte () mais où l'ordre correspond-il?

Je vais essayer de modifier la question pour être plus compréhensible.

@Garry Vass L'ordre de chaque élément de résultat est l'ordre de la liste où ils sont sélectionnés. I.E. Le 1er élément doit être cueilli à partir de la 1ère liste, et une fois que ce nombre est cueilli, vous ne pouvez plus le choisir dans les listes suivantes.

@Ekemann: Chaque liste doit-elle attribuer exactement un entier? Toutes les listes sont-elles commandées par défaut?

@ Timschmelter Oui. J'espère que la question fait un peu plus de sens maintenant.

@Prix, je suppose que je pourrais utiliser cette solution, puis supprimer ceux que je ne peux pas utiliser, même si ce n'est pas très élégant. Merci!

3 Réponses :

3
votes

Cette solution est loin d'être efficace:

    private static void Main()
    {
        List<List<int>> list = new List<List<int>>
            {
                new List<int>() {1, 3, 6}, //Booking 1
                new List<int>() {1, 2, 6}, //Booking 2
                new List<int>() {1}, //Booking 3
                new List<int>() {2, 3}
            };
        List<int[]> solutions = new List<int[]>();
        int[] solution = new int[list.Count];
        Solve(list, solutions, solution);
    }

    private static void Solve(List<List<int>> list, List<int[]> solutions, int[] solution)
    {
        if (solution.All(i => i != 0) && !solutions.Any(s => s.SequenceEqual(solution)))
            solutions.Add(solution);
        for (int i = 0; i < list.Count; i++)
        {
            if (solution[i] != 0)
                continue; // a caller up the hierarchy set this index to be a number
            for (int j = 0; j < list[i].Count; j++)
            {
                if (solution.Contains(list[i][j]))
                    continue;
                var solutionCopy = solution.ToArray();
                solutionCopy[i] = list[i][j];
                Solve(list, solutions, solutionCopy);
            }
        }
    }

1 commentaires

Merci beaucoup ytoledano! Ce n'est pas tellement de performance, ce n'est pas un problème.

5
votes

Résoudre par Récursion: xxx

sortie: xxx

0 commentaires

3
votes

Un moyen simple de regarder ce problème serait de choisir parmi toutes les combinaisons de la liste des valeurs, où chaque valeur de la combinaison est unique.

Premier déterminer ce que toutes les combinaisons de valeurs sont. P >

var collections = new[]
{
    new List<int> { 1, 3, 6 },
    new List<int> { 1, 2, 6 },
    new List<int> { 1 },
    new List<int> { 2, 3 },
};
var results =
    from combination in Combinations(collections)
    where AllUnique(combination)
    select combination;
// results:
//  3,6,1,2
//  6,2,1,3

0 commentaires