Erzeugen Sie gelöste Doppelschokoladenrätsel: Ein Leitfaden für Datenstrukturen und Algorithmen

In diesem Artikel wird eingehend untersucht, wie man automatisch lösbare Rätsel für das Doppel-Choco-Puzzlespiel generiert. Wir werden eine effiziente Datenstruktur einführen - ein Zellobjekt basierend auf einem 2D -Gitter, das Grenzinformationen, Farbe und Zustand enthält. Auf dieser Basis werden wir einen rekursiven Blockerkennungsalgorithmus (ähnlich wie bei der Tiefe-First-Suche) eingehen und wie man ihn in den iterativen Puzzle-Erzeugungsprozess integriert, um sicherzustellen, dass die erzeugten Rätsel den Spielregeln entsprechen und locker sind. Der Artikel bietet Beispielcode und diskutiert wichtige Überlegungen und Optimierungsstrategien im Erzeugungsprozess.

Überblick über das Doppelschokoladen -Puzzle

"Double-Choco" ist ein einzigartiges logisches Puzzle, das vom Nikoli Magazine gestartet wurde. Das Spiel spielt auf einem 2D -Gitter aus weißen und grauen Zellen. Das Ziel des Spielers ist es, das Netz in mehrere "Blöcke" zu teilen, indem sie Linien zeichnen. Jeder Block muss ein Paar weiße und graue Bereiche mit genau der gleichen Form und Größe enthalten. Diese beiden Bereiche können zueinander gedreht oder gespiegelt werden. Einige Bereiche können Zahlen haben, die die Anzahl der Zellen anzeigen, dass sich die Farbe im Block befindet.

Die wichtigste Herausforderung bei der automatischen Erzeugung solcher Rätsel besteht darin, nicht nur Blöcke zu erstellen, die den Grundregeln entsprechen, sondern auch sicherstellen, dass das gesamte Rätsel lösbar ist und keine isolierten Bereiche zurückgelassen werden, die keine rechtlichen Blöcke bilden können.

Kerndatenstruktur Design

Um Puzzletafeln effizient darzustellen und Algorithmen zu unterstützen, empfehlen wir, ein zweidimensionales Array zu verwenden, um benutzerdefinierte "Zell" -Objekte zu speichern. Jedes Zellobjekt sollte die folgenden Eigenschaften enthalten, um seinen Zustand und seine Grenzinformationen vollständig zu beschreiben:

 let cell = {
    X: Nummer, // x Koordinate Y: Nummer, // y Koordinatenfarbe: "Weiß" | "Grau", // Die Farbe der Zelle kann während der Initialisierung leer oder undefiniert werden: NULL | Nummer, // Wenn es eine numerische Eingabeaufforderung gibt, handelt es sich um eine Nummer, sonst ist sie null

    // Grenzflag: Wahre bedeutet, dass es in dieser Richtung eine Grenzlinie (Wand) gibt. Falsch bedeutet, dass es mit benachbarten Zellen oben verbunden ist: boolean, // gibt es eine Grenze über unten: boolean, // befindet sich eine Grenze unter links: boolean, // ist eine Grenze rechts. wird nicht zugeteilt iSoccupied: boolean // Während des Erzeugungsprozesses wurde die Zelle durch einen Block besetzt};

Datenstruktur Erläuterung:

• X, Y: Koordinateninformationen sind leicht zu referenzieren und zu debuggen.
• Farbe: Speichert die Farbe der Zelle, die während der Erzeugungsphase zugeordnet wird.
• Nummer: Wird verwendet, um Puzzle -Eingabeaufforderungen zu speichern.
• Oben, unten, links, rechts: Diese Booleschen Werte sind der Schlüssel zur Definition der Form des Blocks. Wahre bedeutet, dass es in dieser Richtung eine durchgezogene Linie gibt, die die Stromzelle von den angrenzenden Zellen trennt. Falsch bedeutet, dass sie verbunden sind und zum selben Block gehören. Im Anfangszustand kann all dies auf false eingestellt werden, was auf ein vollständig geöffnetes Netz hinweist.
• Blockid: Wird im Blockerkennungsalgorithmus verwendet, um sicherzustellen, dass jede Zelle nur zu einem Block gehört und schnell den Block abfragen kann, zu dem sie gehört.
• ISOCCUPISTIERT: Während des Erzeugungsprozesses, markieren Sie, ob die Zelle einem endgültigen Puzzle -Block zugeordnet wurde, wodurch wiederholte Verarbeitung vermieden wird.

Die Puzzletafel selbst kann als zweidimensionales Array von Zellobjekten dargestellt werden: let board = Array (Zeilen) .Fill (0) .MAP (() => Array (cols) .Fill (0) .MAP (() => ({... cell}));

Blockerkennungsalgorithmus: Blöcke aus dem Netz extrahieren

Der Kern der Erzeugung von Rätseln besteht darin, die im aktuellen Netzstatus gebildeten "Blöcke" genau zu identifizieren. Dies kann durch einen Traversalalgorithmus erreicht werden, der der Tiefen-First-Suche (DFS) oder der Breite-First-Suche (BFS) ähnelt. Der Algorithmus beginnt mit einer unvissiblen Zelle entlang eines Weges ohne Grenzen, sammelt alle verbundenen Zellen, um einen vollständigen Block zu bilden.

 /**
 * Rekursive Funktion: Ausgehend von der angegebenen Zelle, suchen und sammeln Sie alle verbundenen Zellen, um einen Block zu bilden.
 * @param {array <array>>} grid - puzzle grid* @param {number} x - x -Koordinaten der aktuellen Zelle* @param {nummer} y - y -Koordinaten der aktuellen Zelle
 * @param {Array <object>} BlockCellSlist - Wird verwendet, um Listen aller Zellen im aktuellen Block zu sammeln*/
Funktion findBlockcells (Grid, X, Y, CurrentBlockid, BlockcellSlist) {
    // Grenzüberprüfung: Stellen Sie sicher, dass die Koordinaten innerhalb des Gitterbereichs liegen, wenn (x  = grid [0] .Length || y  = grid.length) {
        zurückkehren;
    }
    const cell = grid [y] [x];
    // Überprüfen Sie: Wenn die Zelle einem Block zugewiesen wurde oder in der aktuellen Durchquerung zugegriffen wurde, stoppen Sie, wenn (cell.blockid! == null) {
        zurückkehren;
    }

    cell.blockid = currentBlockid; // die aktuelle Zelle der aktuellen Blockblockcellslist.push (Cell) zuweisen; // Fügen Sie die Zelle der Liste des aktuellen Blocks hinzu // Erforschen Sie benachbarte Zellen rekursiv, vorausgesetzt, es gibt keine Grenzlinie zwischen ihnen, wenn (! Cell.top) findBlockcells (Gitter, x, y - 1, currentBlockid, blockcellSlist);
    if (! cell.bottom) findBlockcells (Grid, x, y 1, currentBlockid, blockcellslist);
    if (! cell.left) findBlockcells (Gitter, x - 1, y, currentBlockid, blockcellslist);
    if (!
}

/**
 * Extrahieren Sie alle unabhängigen Blöcke aus dem gesamten Netz.
 * @param {array <array>>} grid - puzzle grid* @returns {array <array>>} Eine Liste aller identifizierten Blöcke, jeder Block ist eine Liste von Zellen*/
Funktion ExtractAllBlocks (Grid) {
    lass AllBlocks = [];
    Blockcounter = 0;

    // Setzen Sie vor jeder Extraktion die Blockid aller Zellen zurück und identifizieren Sie die Grid.

    für (sei y = 0; y <grid.length y f x="0;" .length wenn die aktuelle zelle keinen bl zugeordnet wurde .blockid="==" null blockcounter generieren sie eine id den neuen block lass currentblockcells="[];" findblockcells if> 0) {
                    Allblocks.push (currentBlockcells);
                }
            }
        }
    }
    AllBlocks zurückgeben;
}</grid.length></array></array></object></array>

Anmerkungen:

• Die FindBlockcells -Funktion ist rekursiv und wird verwendet, um eine einzelne angeschlossene Komponente zu untersuchen.
• Die ExtractallBlocks -Funktion durchquert das gesamte Netz, um sicherzustellen, dass alle nicht zugewiesenen Zellen als Ausgangspunkt für den neuen Block verwendet werden und so alle unabhängigen Blöcke finden.
• Das Zurücksetzen der Blockid ist vor jedem Aufruf von ExtractAllBlocks von entscheidender Bedeutung, um sicherzustellen, dass jede Analyse eine vollständig neue Identifizierung ist, die auf dem aktuellen Grenzzustand basiert.

Puzzle -Erzeugungsalgorithmusprozess

Die Puzzlegenerierung ist ein Prozess der iterativen und Backtracking mit der Kernidee, das Netz allmählich zu füllen, ein Paar weiße und graue Bereiche zu platzieren, die den Regeln jeweils entsprechen, und ihre Grenzen gleichzeitig zu definieren.

1. Initialisieren Sie das Netz:

   • Erstellen Sie ein zweidimensionales Array von MXN-Zellobjekten. Die Isoccups aller Zellen ist auf False eingestellt, die Farbe ist nicht definiert und die Grenzen oben/unten/links/rechts sind alle auf False eingestellt (zeigt an, dass es zu Beginn keine Grenze gibt).

Das obige ist der detaillierte Inhalt vonErzeugen Sie gelöste Doppelschokoladenrätsel: Ein Leitfaden für Datenstrukturen und Algorithmen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!