Algorithme de génération de labyrinthe

Il y a un certain nombre de différent des algorithmes de génération de labyrinthe de , c., méthodes automatisées pour la création des labyrinthes

style=" de

Le labyrinthe montré du côté droit a été produit par la version modifiée de l'algorithme tiré à quatre épingles , ci-dessous. Pour le code source pour un applet de Java qui était responsable, cliquer dessus le labyrinthe.

Théorie

Un labyrinthe est fondamentalement un graphique qui présente un défi de traversal entre deux points. Si le graphique n'est pas relié par , alors il y a des régions du graphique qui sont gaspillées parce qu'ils ne contribuent pas à l'espace de recherche. Si le graphique contient des boucles, alors il peut y avoir les chemins multiples entre les chemins choisis. Pour cette raison, la génération de labyrinthe est souvent approchée en tant que produire d'un aléatoire enjambant - l'arbre sur un graphe connexe. Des boucles qui peuvent confondre les solutionneurs naïfs de labyrinthe peuvent être présentées en ajoutant les bords aléatoires au résultat pendant l'algorithme.

Des algorithmes communs sont basés sur l'enjambement minimal de recherche ou de - des algorithmes de l'arbre pour les graphes connexes, avec des poids de bord choisis aléatoirement. Puisque des labyrinthes sont souvent approchés d'un paradigme différent à la théorie de graphique traditionnelle, la nomenclature différente est utilisée généralement : bords de graphique non inclus dans la résultante enjambant - l'arbre s'appellent le " ; walls" ; ; bords dans l'enjambement - l'arbre s'appellent le " ; passages" ; ; et des sommets s'appellent typiquement le " ; cells" ; ou " ; rooms" ;. Bien que des algorithmes de labyrinthe soient souvent présentés dans le cadre des rangées rectangulaires ou hexagonales, typiquement ils se comportent également bien sur n'importe quel graphe connexe par .

Profondeur-première recherche

Cet algorithme est une version randomisée du Profondeur-premier algorithme de la recherche . le début de

à une cellule particulière et l'appellent le " ; exit." ; La marque de

la cellule courante comme visitée, et obtiennent une liste de ses voisins. Pour chaque voisin, commençant par un voisin aléatoirement choisi : le si ce voisin n'a pas été rendu visite, enlèvent le mur entre cette cellule et ce voisin, et puis le recurse avec ce voisin comme cellule courante.

Si votre architecture informatique a une petite pile et ne peut pas effectivement employer la récursion, vous pouvez stocker l'information de marche arrière dans le labyrinthe elle-même ; ceci fournit également une manière rapide de montrer une solution, en commençant à n'importe quel point donné et en faisant marche arrière à la sortie.

Les labyrinthes produits avec une profondeur-première recherche ont un bas facteur de embranchement et contiennent beaucoup de longs couloirs, qui fait à profondeur-première un bon algorithme pour produire des labyrinthes en jeux vidéo

Dans des labyrinthes produits par cet algorithme, il sera typiquement relativement facile de trouver la manière à la place qui a été sélectionnée la première fois au début de l'algorithme, puisque la plupart des chemins mènent à ou de là, mais trouver dur la sortie.

Backtracker récursif

Le profondeur-premier algorithme de recherche de la génération de labyrinthe est fréquemment mis en application using la marche arrière : la marque de

la cellule courante comme « a visité » le

si la cellule courante a des voisins qui n'ont pas été

visité de

de voisins que la cellule courante sur le
de pile démantèlent le mur entre la cellule courante et le
choisi de cellules faire à la cellule choisie le
courant de cellules périodiquement appeler ce
de la fonction

bruit d'autre de la dernière cellule courante outre du

de pile font marche arrière à l'exécution précédente de cette fonction

L'algorithme de Kruskal randomisé

Cet algorithme est simplement une version randomisée de l'algorithme de Kruskal de . le

créent une liste de tous les murs, et créent un ensemble pour chaque cellule, chacune qui contient juste cela une cellule.

pour chaque mur, dans un certain ordre aléatoire : si les cellules divisées par ce mur appartiennent aux ensembles distincts : le enlèvent le mur courant. Le

joignent les ensembles des cellules autrefois divisées.

Il y a plusieurs structures de données qui peuvent être employées pour modeler les ensembles de cellules. Une exécution efficace using un Disjoindre-a placé la structure de données peut exécuter chaque union et trouver l'opération sur deux ensembles dans le presque-constant amorti le temps (spécifiquement, $O (\ alpha (V)) temps de$ ; le $\ alpha (x) < 5$ pour toute valeur plausible de $x$ ), ainsi le temps de fonctionnement de cet algorithme est essentiellement proportionnel au nombre de murs disponibles au labyrinthe.

Il importe peu si la liste de murs soit au commencement randomisée ou si un mur est aléatoirement choisi d'une liste nonrandom, l'une ou l'autre manière est juste comme facile à coder.

Puisque l'effet de cet algorithme est de produire un enjambement minimal - arbre d'un graphique avec les bords égal-pesés, il tend à produire les modèles réguliers il est assez facile résoudre que.

Algorithme tiré à quatre épingles randomisé

Cet algorithme est une version randomisée de l'algorithme tiré à quatre épingles . début de

avec une grille pleine des murs. La sélection de

une cellule, la marquent en tant qu'élément du labyrinthe. Ajouter les murs de la cellule à la liste de mur.

tandis qu'il y a des murs dans la liste : sélection de un mur aléatoire de la liste. Si la cellule du côté opposé n'est pas dans le labyrinthe pourtant : le font au mur un passage et marquent la cellule du côté opposé en tant qu'élément du labyrinthe. Le

ajoutent les murs voisins de la cellule à la liste de mur.

Comme le profondeur-premier algorithme, il sera habituellement relativement facile de trouver la manière à la cellule commençante, mais de trouver dur la manière n'importe où ailleurs.

Noter cela tiré à quatre épingles classique simplement que courant sur un graphique avec les poids aléatoires créerait des labyrinthes stylistiquement identiques à Kruskal, parce qu'ils sont deux enjambement minimal - des algorithmes d'arbre. Au lieu de cela, cet algorithme présente la variation stylistique parce que les bords plus près du point de départ ont un poids efficace inférieur.

Version modifiée

Bien que l'algorithme tiré à quatre épingles classique garde une liste de bords, parce que de génération de labyrinthe nous pourrions à la place maintenir une liste de cellules adjacentes. Si la cellule aléatoirement choisie a les bords multiples qui la relient au labyrinthe existant, choisir un de ces bords au hasard. Ceci tendra à s'embrancher légèrement davantage que la version bord-basée ci-dessus.

algorithme de Petit-mémoire

D'autres algorithmes existent qui exigent seulement d'assez de mémoire de stocker une ligne d'un 2D labyrinthe ou d'un plan d'un labyrinthe 3D ; ils fonctionnent à côté de stocker quelles cellules dans la ligne courante sont reliées par des cellules dans les lignes précédentes. Cet algorithme ne démantèle jamais un mur entre deux cellules quelconques déjà reliées.

Algorithmes simples

La plupart de génération de labyrinthe que les algorithmes exigent des rapports de maintien entre les cellules dans lui, pour assurer le résultat final sera soluble. Des labyrinthes simplement reliés valides peuvent cependant être produits en se concentrant sur chaque cellule indépendamment. Un labyrinthe d'arbre binaire est un labyrinthe orthogonal standard où chaque cellule a toujours un passage amener ou mener à gauche, mais jamais tous deux. Pour créer un labyrinthe d'arbre binaire, parce que chaque chiquenaude de cellules une pièce de monnaie pour décider si ajouter un passage amenant ou laissé. Sélectionner toujours la même direction pour des cellules sur la frontière, et le résultat final sera un labyrinthe simplement relié valide qui ressemble à un arbre binaire , avec le coin gauche supérieur sa racine.

Une forme relative de renverser une pièce de monnaie pour chaque cellule est de créer une image using un mélange aléatoire des caractères vers l'avant de barre oblique et de barre oblique inverse. Ceci ne produit pas d'un labyrinthe simplement relié valide, mais plutôt d'un choix des boucles bloquées et des passages unicursales. Le générateur de labyrinthe aux algorithmes des edepot, écrits par PO-Han Lin dans juste 5 lignes de code, met en application ceci où le labyrinthe produit est incliné sous un angle en raison des barres obliques.

algorithme Non-cellule-basé

Un labyrinthe peut également être produit sans utilisation des cellules. En l'an 2000, un shareware a appelé AmorphousMaze, apparu sur l'Internet qui crée des labyrinthes avec des murs placés aux angles totalement aléatoires. L'algorithme est basé sur prolonger le mur par un petit segment à la fois sans croiser au-dessus de préexistant. Détail d'algorithme. L'inconvénient de cet algorithme est que le nombre d'essais pour l'intersection est le

O (E^2)

, où

E

est le nombre de ligne segments étant dessinés.

Voir également

Couper-le-noeud .

Random links: