Erstellen von Kombinationen aus einer Reihe von Paaren ohne Wiederholung von Elementen

Ich habe eine Reihe von Paaren. Jedes Paar hat die Form (x, y), sodass x, y zu ganzen Zahlen aus dem Bereich gehören [0,n).

Wenn also n 4 ist, dann habe ich die folgenden Paare:

(0,1) (0,2) (0,3)
(1,2) (1,3) 
(2,3) 

Ich habe schon die Paare. Jetzt muss ich eine Kombination mit n/2Paaren erstellen, sodass sich keine der ganzen Zahlen wiederholt (mit anderen Worten, jede ganze Zahl kommt in der endgültigen Kombination mindestens einmal vor). Es folgen Beispiele für eine richtige und eine falsche Kombination zum besseren Verständnis

 1. (0,1)(1,2) [Invalid as 3 does not occur anywhere]
 2. (0,2)(1,3) [Correct]
 3. (1,3)(0,2) [Same as 2]

Kann mir jemand einen Weg vorschlagen, alle möglichen Kombinationen zu generieren, sobald ich die Paare habe.

Ein direkter Weg ist eine rekursive Prozedur, die bei jedem Aufruf Folgendes ausführt. Die Eingabe für die Prozedur ist eine Liste von Paaren, die bereits ausgewählt wurden, und eine Liste aller Paare.

1. Berechnen Sie die kleinste Zahl, die noch nicht in der Eingabeliste enthalten ist. Für den ersten Aufruf ist dies natürlich 0, da keine Paare ausgewählt wurden.
2. Wenn alle Zahlen abgedeckt sind, haben Sie eine korrekte Kombination. Drucken Sie sie aus und wiederholen Sie den vorherigen Schritt. Ansonsten ist die kleinste Zahl, die aufgedeckt wird, das Ziel, das wir anstreben werden.
3. Durchsuchen Sie die Paare nach einer Möglichkeit, die Zielnummer zu erfassen. Wenn es keine gibt, kehren Sie einfach zur vorherigen Rekursionsebene zurück.
4. Wenn es eine Möglichkeit gibt, die Zielnummer abzudecken, wählen Sie den ersten Weg und rufen Sie die gesamte Prozedur rekursiv erneut auf, wobei das gerade ausgewählte Paar zur Liste der ausgewählten Paare hinzugefügt wird.
5. Suchen Sie nach dem nächsten Weg, um die Zielnummer mit einem Paar zu überdecken, ohne ein zuvor ausgewähltes Paar zu überlappen. Wenn Sie eine finden, wählen Sie sie aus und rufen Sie die nächste Prozedur erneut rekursiv auf.
6. Fahren Sie mit den Schritten 4 und 5 fort, bis die Zielnummer nicht mehr erfasst werden kann. Gehen Sie die gesamte Liste der Paare durch. Wenn die Auswahl nicht mehr korrekt ist, kehren Sie zur vorherigen Ebene der Rekursion zurück.

Die Visualisierung dieses Algorithmus erfolgt mit einem Baum, dessen Pfade Sequenzen nicht überlappender Paare sind. Die erste Ebene des Baums enthält alle Paare, die 0 enthalten. Im obigen Beispiel ist der Baum

           Wurzel
             |
     ----------------
     | | |
   (0,1) (0,2) (0,3)
     | | |
   (2,3) (1,3) (1,2)

In diesem Beispiel geben alle Pfade durch den Baum tatsächlich korrekte Sammlungen an. Wenn wir jedoch beispielsweise das Paar (1,2) weglassen, hat der Pfad ganz rechts nur einen Knoten und entspricht der Suche in Schritt 3, die fehlschlägt.

Suchalgorithmen dieses Typs können für viele ähnliche Probleme der Aufzählung aller Objekte eines bestimmten Typs entwickelt werden.

Möglicherweise bedeutete das OP, dass sich alle Paare in der Eingabe befanden und nicht nur eine Gruppe von ihnen, wie in der Frage angegeben. In diesem Fall ist der Algorithmus viel einfacher, da nicht mehr überprüft werden muss, welche Paare zulässig sind. Es ist nicht einmal erforderlich, die Menge aller Paare zu generieren. Der folgende Pseudocode erfüllt die Anforderungen des OP. Hier ist die Eingabenummer, "Liste" beginnt als leere Liste, und "verdeckt" ist ein Array mit der Länge auf 0 initialisiert ist. Es könnte etwas effizienter gestaltet werden, aber das ist nicht mein unmittelbares Ziel.$n$$n$

sub cover {
  i = 0;
  while ( (i < n) && (covered[i] == 1 )) {
   i++;
  }
  if ( i == n ) { print list; return;}
  covered[i] = 1;
  for ( j = 0; j < n; j++ ) {
    if ( covered[j] == 0 ) {
      covered[j] = 1;
      push list, [i,j];
      cover();
      pop list;
      covered[j] = 0;
    }
  }
  covered[i] = 0;
}

Sie können es iterativ lösen. Angenommen, Sie haben alle Lösungen für den Bereich . Dann können Sie einfach die Lösungen aus konstruieren . Die Größe wächst mit sehr schnell. Es kann daher sinnvoll sein, einen Generator zu schreiben, anstatt alle Sets im Speicher zu halten (siehe Python-Beispiel unten). [ 0 , n ) S n + 2 S n$S_n$$[0,n)$$S_{n+2}$$S_n$$n$

def pairs(n):
    if (n%2==1 or n<2):
        print("no solution")
        return
    if (n==2):
        yield(  [[0,1]]  )
    else:
        Sn_2 = pairs(n-2) 
        for s in Sn_2:
            yield( s + [[n-2,n-1]] )
            for i in range(n/2-1):
                sn = list(s)
                sn.remove(s[i])
                yield( sn + [ [s[i][0], n-2] , [s[i][1], n-1] ] )
                yield( sn + [ [s[i][1], n-2] , [s[i][0], n-1] ] )

Sie können alle Paare auflisten, indem Sie anrufen

for x in pairs(6):
   print(x)

Update : Meine frühere Antwort befasste sich mit zweigeteilten Graphen, nach denen das OP NICHT fragte. Ich lasse es im Moment als verwandte Informationen. Die sachdienlicheren Informationen beziehen sich jedoch auf perfekte Übereinstimmungen in nicht zweigeteilten Diagrammen.

In dieser Hinsicht gibt es eine schöne Umfrage von Propp , in der die Fortschritte (bis 1999) skizziert werden. Einige der Ideen in diesem Artikel und die zugehörigen Links könnten sich als nützlich erweisen. die TL; DR ist - es ist knifflig :)

--- Beginn der alten Antwort

Beachten Sie, dass Sie alle möglichen perfekten Übereinstimmungen in einem zweigeteilten Diagramm auflisten müssen. Hierzu gibt es viele verschiedene Algorithmen, insbesondere einen neueren aus dem ISAAC 2001 .

Die Grundidee besteht darin, mithilfe von Netzwerkflüssen eine perfekte Übereinstimmung zu finden und diese dann wiederholt mithilfe alternierender Zyklen zu ändern (weitere Informationen finden Sie im Lehrbuch zu Algorithmen im Kapitel zu Netzwerkflüssen).

Jedes Paar, das Sie auswählen, eliminiert zwei Reihen, aus denen Sie nicht mehr auswählen können. Diese Idee kann verwendet werden, um einen rekursiven Algorithmus (in Scala) einzurichten:

def combine(pairs : Seq[(Int,Int)]) : Seq[Seq[(Int, Int)]] = pairs match {
  case Seq() => Seq()
  case Seq(p) => Seq(Seq(p))
  case _ => {
    val combinations = pairs map { case (a,b) => {
      val others = combine(pairs filter { case (c,d) =>
        a != c && a != d && b != c && b != d
      })

      others map { s => ((a,b) +: s) }
    }}

    combinations.flatten map { _.sorted } distinct
  }
}

Dies kann sicherlich effizienter zum Ausdruck gebracht werden. Insbesondere wird die Idee, nicht ganze Zeilen für Kombinationen berücksichtigen zu müssen, vom Aufruf an nicht verwendet filter.

Es gibt zwar bereits viele nette Antworten auf die Frage, aber ich denke, es wäre schön, auf den grundlegenden, allgemeinen Trick hinzuweisen, der dahintersteckt.

Es ist viel einfacher, eindeutige Kombinationen zu generieren, wenn Sie eine Gesamtreihenfolge der zu kombinierenden Elemente haben . Auf diese Weise ist die Eindeutigkeit garantiert, wenn wir nur sortierte Kombinationen zulassen. Es ist auch nicht schwer, die sortierten Kombinationen zu generieren - führen Sie einfach die übliche Brute-Force-Aufzählungssuche durch, sondern wählen Sie bei jedem Schritt nur Elemente aus, die größer sind als die, die bereits bei jedem Schritt ausgewählt wurden.

Die zusätzliche Komplikation bei diesem speziellen Problem ist der Wunsch, nur die Kombinationen der Länge n / 2 (der maximalen Länge) zu erhalten. Dies ist nicht schwer zu tun, wenn wir uns für eine gute Sortierstrategie entscheiden. Wenn wir zum Beispiel, wie in Carl Mummets Antwort ausgeführt, eine lexikografische Sortierung betrachten (von oben nach unten, von links nach rechts im Diagramm der Frage), leiten wir die Strategie ab, immer das nächste Element so zu nehmen, dass dessen erste Ziffer die ist kleinste noch unbenutzte Nummer.

Wir können diese Strategie auch erweitern, wenn wir Sequenzen anderer Länge erzeugen wollen. Denken Sie daran, dass bei der Auswahl eines nächsten Elements, dessen erste Nummer nicht die kleinste verfügbare ist, die Anzeige einer oder mehrerer Elementreihen in der sortierten Teilsequenz ausgeschlossen wird, sodass sich die maximale Länge der Prermutation entsprechend verringert.

Ich bin nicht sicher, ob dies das ist, wonach Sie fragen, aber wie ich verstehe, haben Sie alle ungeordnete Paare von und möchten die Liste aller Paare zählen, die decken Sie die Menge wobei eine gerade Zahl ist. Wir können uns dies als Kantenbedeckung von , dem vollständigen Graphen auf Ecken.$n \choose 2$$[n] = \{1, \cdots, n\}$$[n]$$n$$K_n$$n$

Außerdem scheint die Frage anzunehmen, dass jede Zahl in nur einmal in der Liste vorkommt. In diesem Fall betrachten wir nur die Abdeckungen, die perfekt zusammenpassen . Die Anzahl der Übereinstimmungen in einem Diagramm entspricht der Permanenz seiner Adjazenzmatrix . Wir müssen also berechnen .$[n]$$\mathsf{Perm}(K_n)$

Es ist bekannt, dass permanent , aber dies ist im Allgemeinen der Fall. Für gibt es solche Listen. $\mathsf{\#P\text{-}complete}$ $K_n$$\frac{n!}{2^{\frac{n}{2}}}$

Der einfachste Weg, um all dies zu generieren, besteht darin, eine perfekte Übereinstimmung festzulegen und dann eine Permutation von anzuwenden. Dadurch werden jedoch viele Duplikate generiert.$[n]$