Algoritmo de la generación del laberinto

Hay un número de diverso de los algoritmos de la generación del laberinto del, es decir, métodos automatizados para la creación de los laberintos

style=" del

El laberinto demostrado a la derecha ha sido generado por la versión modificada del algoritmo remilgado, abajo. Para el código fuente para un applet de Java que era responsable, chascar encendido el laberinto.

Teoría

Un laberinto es básicamente un gráfico que presenta un desafío del traversal entre dos puntos. Si el gráfico no es conectado, después hay las regiones del gráfico se pierden que porque no contribuyen al espacio de búsqueda. Si el gráfico contiene lazos, después puede haber trayectorias múltiples entre las trayectorias elegidas. Debido a esto, la generación del laberinto se acerca a menudo como generación de un al azar que atraviesa - el árbol en un gráfico conectado. Los lazos que pueden confundir a disolventes ingenuos del laberinto pueden ser introducidos agregando los bordes al azar al resultado durante el curso del algoritmo.

Los algoritmos comunes se basan en atravesar mínimo de la búsqueda o - los algoritmos del árbol para los gráficos conectados, con los pesos del borde elegidos aleatoriamente. Porque los laberintos se acercan a menudo de un diverso paradigma a la teoría de gráfico tradicional, diversa nomenclatura es de uso general: bordes del gráfico no incluidos en el resultado que atraviesa - el árbol se llama " walls" ; bordes en atravesar - el árbol se llama " passages" ; y las cimas típicamente se llaman " cells" o " rooms". Aunque los algoritmos del laberinto se presenten a menudo en el contexto de órdenes rectangulares o hexagonales, se realizan típicamente igualmente bien en cualquier gráfico conectado .

Profundidad-primera búsqueda

Este algoritmo es una versión seleccionada al azar del Profundidad-primer algoritmo de la búsqueda . El comienzo del

en una célula particular y la llama el " exit."

Marcar la célula actual según lo visitado, y conseguir una lista de sus vecinos. Para cada vecino, comenzando con un vecino aleatoriamente seleccionado: Si no han visitado a ese vecino, quitar la pared entre esta célula y ese vecino, y entonces el recurse con ese vecino como la célula actual.

Si su arquitectura de computadora tiene un pequeño apilado y no puede utilizar eficazmente la repetición, usted puede almacenar la información en el laberinto sí mismo de la vuelta hacia atrás; esto también proporciona una manera rápida de exhibir una solución, comenzando en cualquier punto dado y retrocediendo a la salida.

Los laberintos generados con una profundidad-primera búsqueda tienen un factor de ramificación bajo y contienen muchos pasillos largos, que hace profundidad-primera un buen algoritmo para generar los laberintos en los juegos video

En los laberintos generados por ese algoritmo, será típicamente relativamente fácil encontrar la manera al cuadrado que primero fue escogido al principio del algoritmo, puesto que la mayoría de las trayectorias llevan a o desde allí, pero encontrar difícilmente la salida.

Backtracker recurrente

El profundidad-primer algoritmo de búsqueda de la generación del laberinto se ejecuta con frecuencia usar la vuelta hacia atrás : Marca del

la célula actual como

“visitado” Si la célula actual tiene algunos vecinos que no hayan sido

visitado del

unvisited de los vecinos Empujar la célula actual en el
del apilado Golpear abajo la pared entre la célula actual y el
elegido de la célula Hacer la célula elegida el
actual de la célula Llamar recurrentemente este
de la función

otro del

del apilado Retroceder a la ejecución anterior de esta función

Algoritmo de Kruskal seleccionado al azar

Este algoritmo es simplemente una versión seleccionada al azar del algoritmo de Kruskal.

crea una lista de todas las paredes, y crea un sistema para cada célula, cada uno que contiene apenas eso una célula.

Para cada pared, en una cierta orden al azar: Si las células divididas por esta pared pertenecen a los sistemas distintos: Quitar la pared actual.

Ensamblar los sistemas de las células antes divididas.

Hay varias estructuras de datos que se pueden utilizar para modelar los sistemas de células. Una puesta en práctica eficiente usar un Desunir-fijó la estructura de datos puede realizar cada unión y encontrar la operación en dos sistemas en el casi-constante amortizado el tiempo (específicamente, $O (\ (V)) tiempo alfa de$ ; el $\ la alfa (x) < 5$ para cualquie valor plausible de $x$ ), así que el tiempo en marcha de este algoritmo es esencialmente proporcionales al número de paredes disponibles para el laberinto.

Importa poco si la lista de paredes esté seleccionada al azar inicialmente o si una pared se elige aleatoriamente de una lista nonrandom, cualquier manera está apenas como fácil cifrar.

Porque el efecto de este algoritmo es producir atravesar mínimo - árbol de un gráfico con los bordes igual-cargados, tiende a producir los patrones regulares que son bastante fáciles de solucionar.

Algoritmo remilgado seleccionado al azar

Este algoritmo es una versión seleccionada al azar del algoritmo remilgado . Comienzo del

con una rejilla llena de paredes.

Escoger una célula, marcarla como parte del laberinto. Agregar las paredes de la célula a la lista de la pared.

Mientras que hay paredes en la lista: Escoger una pared al azar de la lista. Si la célula en el lado opuesto no está en el laberinto con todo: Hacer la pared un paso y marcar la célula en el lado opuesto como parte del laberinto.

Agregar las paredes vecinas de la célula a la lista de la pared.

Como el profundidad-primer algoritmo, será generalmente relativamente fácil encontrar la manera a la célula que comienza, pero encontrar difícilmente la manera en cualquier otro lugar.

Observar eso remilgado clásico simplemente que corriente en un gráfico con los pesos al azar crearía los laberintos estilístico idénticos a Kruskal, porque son ambos el atravesar mínimo - los algoritmos del árbol. En lugar, este algoritmo introduce la variación estilística porque los bordes más cercano al punto de partida tienen un peso eficaz más bajo.

Versión modificada

Aunque el algoritmo remilgado clásico guarde una lista de bordes, porque de generación del laberinto podríamos en lugar de otro mantener una lista de células adyacentes. Si la célula aleatoriamente elegida tiene bordes múltiples que la conecten con el laberinto existente, seleccionar uno de estos bordes al azar. Esto tenderá a ramificar levemente más que la versión borde-basada arriba.

algoritmo de la Pequeño-memoria

Otros algoritmos existen que requieren solamente bastante memoria almacenar una línea de un 2.o laberinto o de un plano de un laberinto 3D; trabajan almacenando qué células en la línea actual están conectadas a través de las células en las líneas anteriores. Este algoritmo nunca golpea abajo una pared entre cualquier dos células conectadas ya.

Algoritmos simples

La mayoría de la generación del laberinto que los algoritmos requieren relaciones que mantienen entre las células dentro de él, para asegurar el resultado final será soluble. Los laberintos simplemente conectados válidos pueden sin embargo ser generados centrándose en cada célula independiente. Un laberinto del árbol binario es laberinto ortogonal estándar donde cada célula tiene siempre un paso el conducir o el llevar a la izquierda, pero nunca ambos. Para crear un laberinto del árbol binario, porque cada tirón de la célula una moneda para decidir si agregar un paso que conduce o dejado. Escoger siempre la misma dirección para las células en el límite, y el resultado final será un laberinto simplemente conectado válido que parece un árbol binario, con la esquina superior izquierdo su raíz.

Una forma relacionada de mover de un tirón una moneda para cada célula es crear una imagen usar una mezcla al azar de carácteres delanteros de la raya vertical y de la barra. Esto no genera un laberinto simplemente conectado válido, sino algo una selección de lazos cerrados y pasos unicursal. El generador del laberinto en los algoritmos de los edepot, sidos autor por Po-Han Lin en apenas 5 líneas de código, ejecuta esto donde el laberinto generado se inclina en ángulo debido a las rayas verticales.

algoritmo No-célula-basado

Un laberinto se puede también generar sin el uso de células. En año-2000, un shareware llamó AmorphousMaze, aparecido en el Internet que crea los laberintos con las paredes colocadas en los ángulos total al azar. Cuadro de la muestra. El algoritmo es basado en ampliar la pared por un pequeño segmento a la vez sin cruzar sobre preexistente. Detalle del algoritmo. La desventaja de este algoritmo es que el número de pruebas para la intersección es el

O (E^2)

, donde está el número

E

de línea segmentos que son dibujados.

Ver también

Cortar--nudo .

Zenithic

Blind Faith (Legend Seven album)

Random links:

Endocytosis | Enki Bilal | Andrei Kivilev | Juego ahorrado | Ciruelo de Don