BUSQUEDA CON RETROCESO

La bsqueda con retroceso, o backtracking, es una estrategia tentativa. El procedimiento lleva la cuenta de las reglas aplicadas. Si en el transcurso de la bsqueda se llega a un punto muerto, puede olvidar o "deshacer" la ltima regla aplicada y probar una nueva alternativa. Esto permite, en principio, explorar todos los caminos de un grafo a partir de un nodo inicial, siempre que sea finito y se compruebe la aparicin de ciclos.

El procedimiento RETROCESO recibe un estado inicial y devuelve: bien el camino de estados que lleva a un estado objetivo; o bien 'FRACASO' si no pudo encontrarse ningn camino solucin.

Aunque la idea de base es sencilla, pueden considerarse distintas implementaciones de la bsqueda con retroceso concretamente analizaremos dos versiones:

La primera, que denominaremos backtrack, es una versin recursiva en la que la secuencia de nodos examinados se guarda en los entornos de las sucesivas llamadas recursivas.

La segunda, que denominaremos retroceso, es una versin recursiva por la cola que manipula explcitamente una estructura de datos donde se guarda explcitamente el camino que se est examinando.

A) PROCEDIMIENTO BACKTRACK
El procedimiento BACKTRACK recibe un estado e intenta encontrar un camino solucin partiendo de l. Para ello genera un nico sucesor y realiza una llamada recursiva. Si esta fracasa, se genera otro sucesor y se vuelve a realizar una llamada recursiva. Si las llamadas correspondientes a todos los sucesores fracasan, entonces se termina devolviendo FRACASO. Si en algn momento se encuentra un estado final, se termina con xito, y la secuencia de retornos de las distintas llamadas construyen una lista con el camino solucin.

PROCEDIMIENTO BACKTRACK
backtrack(E)

Si finalp(E)
entonces devolver (cons(E, NIL)); en otro caso, Para cada regla R aplicable a E

E2 aplicar-regla(R,E);
SOLUCION backtrack(E2); Si SOLUCION <> FRACASO entonces devolver (cons(E,SOLUCION));

fin/para
devolver (FRACASO); fin backtrack;

B) PROCEDIMIENTO RETROCESO
El procedimiento RETROCESO realiza una exploracin similar a la de BACKTRACK. La diferencia est en la implementacin, que en el caso de RETROCESO responde a una funcin recursiva por la cola ms verstil, y que permite la comprobacin de ciclos. Para llevar la cuenta de los estados y reglas considerados, RETROCESO utiliza una lista de nodos. Cada nodo estar formado por dos elementos: un estado;

una lista de las reglas aplicables a dicho estado y que an no han sido probadas.

Supondremos definidas las operaciones: hacer-nodo(E, LR), que recibe un estado E y una lista de reglas LR y devuelve un nodo. estado(N), que recibe un nodo N y devuelve el estado asociado. lista-reglas (N), que recibe un nodo N y devuelve la lista de reglas asociada.

Tambin supondremos que NIL denota la lista vaca, y que estn definidas las operaciones sobre listas: aadir(X,L), que recibe un elemento X y una lista L, y devuelve una nueva lista cuyo primer elemento es X, y a continuacin todos los de la lista L, es decir, en notacin Prolog, la lista [X|L]. cabeza(L), que recibe una lista L y devuelve su primer elemento. resto(L), que recibe una lista L y devuelve una lista igual que L tras eliminar su primer elemento. vaco(L), que recibe una lista L y devuelve 'cierto' si L es la lista vaca, y 'falso' en otro caso.

PROCEDIMIENTO RETROCESO
retroceso(E0); LR N reglas-aplicables(E0); hacer-nodo(E0, LR);

CAMINO aadir(N, NIL);

devolver(rtr(CAMINO)); fin-retroceso.

PROCEDIMIENTO RTR
rtr(CAMINO);

NODO
E LR R

cabeza (CAMINO);

estado (NODO); lista-reglas (NODO); cabeza (LR); vaco (CAMINO) : es-objetivo (E): vaco (LR): otro-caso: devolver ('FRACASO'); devolver (CAMINO); devolver (rtr (resto (CAMINO))); LR2 resto (LR);

segn:

NODO2

hacer-nodo (E, LR2);

aadir(NODO2, resto (CAMINO));

NUEVO-CAM fin-segn; fin-rtr.

devolver (rtr (avanzar (E,R, NUEVO-CAM)));

Las cuatro condiciones de la estructura 'segn' corresponden al fracaso, xito, retroceso y avance respectivamente. Las dos primeras suponen la terminacin de la bsqueda, mientras que las restantes la continan.

Ntese que cuando se prueba una regla de un nodo, la lista de reglas correspondiente debe ser actualizada. Ntese tambin que 'rtr' es una funcin recursiva por la cola.

La funcin 'avanzar (E,R, CAM)' recibe un estado E, una regla R aplicable a E, y un camino CAM, y devuelve un camino igual que CAM, pero que adems tiene a la cabeza el estado resultante de aplicar R a E.

Segn la naturaleza del problema que se pretenda resolver puede realizarse o no la comprobacin de ciclos. Si los ciclos son imposibles, entonces comprobarlos es una prdida de tiempo. Si los ciclos son posibles, no comprobarlos puede ser nefasto. Veamos versiones para ambas posibilidades:

AVANZAR(E,R,CAMINO) E2 LR2 NODO

;versin que no comprueba ciclos

aplicar (R, E); reglas-aplicables (E2); hacer-nodo (E2, LR2);

devolver (aadir (NODO, CAMINO)); AVANZAR(E,R,CAMINO) E2 aplicar (R, E); devolver(CAMINO); reglas-aplicables (E2); ;versin que s comprueba ciclos

Si repetido(E2,CAMINO) entonces si-no NODO LR2

hacer-nodo (E2, LR2);

devolver (aadir (NODO, CAMINO));

donde la funcin 'repetido(E,CAMINO)' devuelve: 'cierto' si el estado de algn nodo del CAMINO es igual a E; o 'falso' en otro caso.

EJEMPLO:
Sea el grafo de la figura. El estado inicial es el etiquetado como E1, y el final el etiquetado como E4. Supongamos que las reglas se prueban siempre en el orden creciente (R1, R2, R3, R4, R5, R6). En este grafo (un rbol, en realidad) no se presentan ciclos, por lo que puede utilizarse sin peligro la primera versin de 'avanzar'.

La llamada a 'retroceso(E1)' construye una lista formada por un nico nodo:

A continuacin se realiza la primera llamada a rtr, donde: NODO es

E es E1
LR es (R1, R2, R3) R es R1 E1 (R1, R2, R3)

El resultado es una segunda llamada recursiva a rtr con la lista:

y donde: NODO es

E es E2
LR es ( ) R no toma valor E2 ( )

El resultado es una tercera llamada a rtr con la lista:

El resultado es una cuarta llamada a rtr con la lista:

El resultado es una quinta llamada a rtr con la lista:

Como E4 es el estado final, la bsqueda termina con xito devolviendo el camino resultante.