Algorithme de produit cartésien efficace

vous ne pouvez pas vraiment changer la performance d'une boucle imbriquée sans quelques connaissances supplémentaires, mais cela serait spécifique à l'utilisation. Si vous avez n éléments is et m éléments js, il est toujours en O(n*m).

Vous pouvez changer le de bien:

var qry = from i in is
          from j in js
          select /*something involving i/j */;

C'est toujours en O(n*m), mais a nominal extra au-dessus de LINQ (vous ne le remarquerez pas dans l'usage normal, Cependant).

Qu'êtes-vous faire dans cas? Il y a peut être des trucs...

Une chose à certainement eviter est tout ce qui oblige une jonction croisée à amortir-le foreach approche est fine et n'a pas de tampon, mais si vous ajoutez chaque élément à un List<>, alors méfiez-vous des implications de mémoire. Idem OrderBy etc (si utilisé de manière inappropriée).

je ne peux pas proposer quelque chose de mieux, que O(n^2), parce que c'est le taille de la sortie, et l'algorithme ne peut donc pas être plus vite.

ce que je peux suggérer est d'utiliser une autre approche à savoir si vous avez besoin de calculer produit. Par exemple, vous n'avez peut-être même pas besoin de l'ensemble de produits P si seulement vous allez à se demander si certains éléments font partie. Vous n'avez besoin que des informations sur les décors.

en Effet (pseudo-code)

bool IsInSet(pair (x,y), CartesianProductSet P)
{
   return IsInHash(x,P.set[1]) && IsInHash(y,P.set[2])
}

où le produit Cartésien est calculé comme ceci:

// Cartesian product of A and B is
P.set[1]=A; P.set[2]=B;

si vous implémentez des sets comme hashes, alors cherchez dans un produit cartésien de m ensembles est juste une recherche dans m hachages vous obtenez gratuitement. Construction du produit cartésien et IsInSet rechercher chaque prise O(m) fuseau, où m est un nombre de sets que vous multipliez, et c'est beaucoup moins que n--taille de chaque ensemble.

des renseignements supplémentaires ont été ajoutés à la question.

les doublons peuvent être évités si vous enregistrez ceux que vous avez déjà calculés afin d'éviter de les dupliquer à nouveau - il est supposé que le coût d'une telle comptabilité - un hashmap ou une simple liste - est moins que le coût de calcul d'un duplicata.

le C # runtime est vraiment très rapide, mais pour le levage extrême lourd, vous pourriez vouloir tomber dans le code natif.

vous pourriez aussi remarquer l'essentiel parallelness de ce problème. Si le calcul d'un produit n'a pas d'impact sur le calcul de tout autre produit, vous pouvez directement utiliser un processeur multiples noyaux pour faire le travail en parallèle. Regardez pool de threads.QueueUserWorkItem.

si la localisation du cache (ou la mémoire locale requise pour maintenir les j) est un problème, vous pouvez rendre votre algorithme plus convivial en divisant les tableaux d'entrées de façon récursive. Quelque chose comme:

cartprod(is,istart,ilen, js,jstart,jlen) {
  if(ilen <= IMIN && jlen <= JMIN) { // base case
    for(int i in is) {
      for(int j in js) {
        // pair i and j
      }
    }
    return;
  }
  if(ilen > IMIN && jlen > JMIN) { // divide in 4
    ilen2= ilen>>1;
    jlen2= jlen>>1;
    cartprod(is,istart,ilen2,            js,jstart,jlen2);
    cartprod(is,istart+ilen2,ilen-ilen2, js,jstart,jlen2);
    cartprod(is,istart+ilen2,ilen-ilen2, js,jstart+jlen2,jlen-jlen2);
    cartprod(is,istart,ilen2,            js,jstart+jlen2,jlen-jlen2);
    return;
  }
  // handle other cases...
}

notez que ce pattern d'accès va automatiquement profiter assez bien de tous les niveaux de cache automatique; ce genre de technique s'appelle cache-inconscients conception de l'algorithme.

Je ne sais pas comment écrire Java-like-Iterators en C#, mais peut-être que vous savez et pouvez transférer ma solution ici pour C# vous-même.

il peut être intéressant si vos combinaisons sont trop grandes pour les garder complètement en mémoire.

cependant, si vous filtrez par attribut sur la collection, vous devriez filtrer avant de construire la combinaison. Exemple:

si vous avez des nombres de 1 à 1000 et des mots aléatoires et les combiner, puis filtrer ces combinaisons, où le nombre est divisible par 20 et le mot commence par "d", vous pouvez avoir 1000*(26*x)=26000*x combinaisons à rechercher.

ou vous filtrez les nombres en premier, ce qui vous donne 50 nombres, et (si distribués également) 1 caractère, qui sont seulement 50*x éléments à la fin.