Backtracking. 1

ALGORÍTMICA

Backtracking.

1. Método general.

2. Ejemplos de aplicación.2.1. Problema de las N reinas.

2.2 Problema del Laberinto.

2.3 Coloreado de Grafos.

2.4 Resolución de juegos.

Backtracking. 2

1. Método general.

• El backtracking (método de retroceso ó vuelta atrás) es una técnica general de resolución de problemas, aplicable tanto a problemas de optimización, juegos y otros tipos.

• El backtracking realiza una búsqueda exhaustiva y sistemática en el espacio de soluciones. Por ello, suele resultar ineficiente.

• La solución de un problema de backtracking se puede expresar como una tupla (x1, x2, ..., xn), satisfaciendo unas restricciones P(x1, x2, ..., xn) y tal vez optimizando una cierta función objetivo.

• En cada momento, el algoritmo se encontrará en un cierto nivel k, con una solución parcial (x1, ..., xk). Si esta solución parcial es válida se puede añadir un nuevo elemento a la solución avanzando al nivel k+1 y probando los valores para xk+1

Backtracking. 3

1. Método general.

• Si no, se prueban otros valores de xk.

• Si no existe ningún otro valor posible por probar, entonces se retrocede al nivel anterior k-1.

• Se sigue hasta que la solución parcial sea una solución completa del problema, o hasta que no queden más posibilidades.

• El resultado es equivalente a hacer un recorrido en profundidad en el árbol de soluciones. Sin embargo, este árbol es implícito, no se almacena en ningún lugar.

• Ejemplo. Dado un conjunto de números enteros {13, 11, 7}, encontrar si existe algún subconjunto cuya suma sea exactamente 20.

Backtracking. 4

1. Método general.• Posibilidad 1) En cada nivel i decidir si el elemento i está o

no en la solución. Representación de la solución: (x1, x2, x3), donde xi= (0, 1).

k=1 (13)

k=2 (11)

k=3 (7)

10 1

5

2

3 6

4 87

010

10

1

12

9

10 13

11 1514

010

10

1

0 7 11 1318 20 24 31 Sumas totales

• Cada nodo representa un paso del algoritmo, una solución parcial en cada momento dado. El árbol indica un orden de ejecución (recorrido en profundidad) pero no se almacena en ningún lugar.

• Una solución es un nodo hoja con valor de suma 20.• Posible mejora: No probar con los nodos cuya suma va a exceder

el valor 20.

Árbol de soluciones 1

Backtracking. 5

1. Método general.SUBPROGRAMA BackTracking (IN k:INTEGER,OUT Solucion:INTEGER[1..N],

IN Suma:INTEGER, OUT Fin:BOOLEAN, IN PMAX:INTEGER, IN Valor:INTEGER[1..N]):void

BEGINIF (K > N) THEN

IF (Suma==PMAX) THEN Fin=TRUE;ELSE

BEGINSolucion[k]=0;Backtracking(k+1,Solucion,Suma,Fin,PMAX,Valor);IF (¬ FIN) THEN

BEGIN Solucion[k]=1;

Backtracking(k+1,Solucion,Suma+Valor[k],Fin,PMAX,Valor);

ENDEND

END; Backtarcking(1,(0,0,0),0,FALSE,20,(13,11,7));

Backtracking. 6

1. Método general.• Posibilidad 2) En cada nivel i decidir qué elemento se añade (1, 2 ó 3).

Representación de la solución (s1, ..., sm), donde mn y si {1, 2, 3}.

Árbol de soluciones 2

• Cada nodo es una posible solución. Será válida si la suma es 20.• El recorrido es también en profundidad.• Necesitamos funciones para generar los nodos, para descartar

nodos y para saber si un nodo es solución.

k=1

k=2

k=3

1 3

2

5

3

7

63

21

8

20

7 9

0 2

13

Backtracking. 7

1. Método general.SUBPROGRAMA BackTracking2(IN k:INTEGER,OUT Solucion:INTEGER[1..N],

IN Cantidad:INTEGER, IN elemento:INTEGER,IN Valor:INTEGER[1..N]):voidVAR

i:INTEGER;BEGIN

FOR i IN k..N DOBEGIN

IF (elemento<=N) ^ (Valor[elemento]<=Cantidad) THENBEGIN

Solucion[k]=elemento;IF (Cantidad-Valor[elemento] == 0) THEN PROCESAR(Solucion);ELSE Backtracking2(k+1,Solucion, Cantidad-Valor[elemento],

elemento+1,Valor);END

elemento=elemento+1;END

END; Backtarcking2(1,(0,0,0),20,1,(13,11,7));

Backtracking. 8

k=2 Cant=7 Sol=(1,0,0) elem=2 i=2 k=2 Cant=7 Sol=(1,3,0) elem=3 i=3

k=1 Cant=20 Sol=(1,0,0) elem=1 i=1

k=1 Cant=20 Sol=(2,0,0) elem=2 i=2

k=1 Cant=20 Sol=(3,0,0) elem=3 i=3

1. Método general.

k=3 Cant=0 Sol=(1,3,0) elem=4 i=3

k=3 Cant=2 Sol=(2,3,0) elem=4 i=3

k=2 Cant=13 Sol=(3,0,0) elem=4 i=2

k=2 Cant=9 Sol=(2,0,0) elem=3 i=2 k=2 Cant=9 Sol=(2,0,0) elem=4 i=3

Backtracking. 9

1. Método general.

• Sea (x1, x2, ..., xi-1) un camino de la raíz hasta un nodo del árbol del espacio de estados.

• Sea G(x1, x2, ..., xi-1) el conjunto de los valores posibles de xi tales que (x1, x2, ..., xi) es un camino hasta un nodo del árbol.

• Suponemos que existe algún predicado acotador A tal que A (x1, x2, ..., xi) es falso si el camino (x1, x2, ..., xi) no puede extenderse para alcanzar un nodo de respuesta (i.e., una solución).

• Por tanto, los candidatos para xi son los valores de G tales que satisfacen A.

• Supongamos, finalmente, que existe un predicado R que determina si un camino (x1, x2, ..., xi) termina en un nodo respuesta (i.e., es ya una solución).

Backtracking. 10

1. Método general.SUBPROGRAMA retroceso(IN k:INTEGER,

OUT solución:elemento[1..N]):voidVAR

nodo:elemento;BEGIN

PARA TODO nodo en G(solución,1,k-1) DOBEGIN

solución[k]=nodo;IF A(solución,1,k)THEN

BEGINIF R(solución,1,k) THEN guardar(solución,1,k);retroceso(k+1,solución);

ENDEND

END;

Backtracking. 11

1. Método general.

• Nótese que el árbol no se construye explícitamente sino implícitamente mediante las llamadas recursivas del algoritmo de búsqueda.

• El algoritmo no hace llamadas recursivas cuando:

- k = N+1, o cuando- ningún nodo generado por G satisface A.

• Backtracking = búsqueda en profundidad y con predicados acotadores.

• El algoritmo anterior halla todas las soluciones y además éstas pueden ser de longitud variable.

Backtracking. 12

Variantes:

•Limitar el número de soluciones a una sola añadiendo un parámetro boolean de salida que indique si se ha encontrado una solución.

•Forzar a que sólo los nodos hoja puedan significar solución (realizando la recursión sólo si no se ha encontrado un nodo solución):

IF R(solución,1,k) THEN guardar(solución,1,k);

ELSE retroceso(k+1,solución);

•Resolver problemas de optimización: además de la solución actual en construcción hay que guardar la mejor solución encontrada hasta el momento.

1. Método general.

Backtracking. 13

• El problema consiste en colocar N reinas en un tablero de ajedrez sin que se den jaque (dos reinas se dan jaque si comparten fila, columna o diagonal).

• Cada solución se representa por una n-tupla (x1, x2,.., xi), en la que xi es la columna de la i-ésima fila en la que se coloca la i-ésima reina.

• El espacio de soluciones se reduce a n! elementos teniendo en cuenta que todas ellas han de ser permutaciones de (1,2,…,n), es decir, todas las xi han de ser distintas.

• Además, no deben compartir diagonal.

Problema de las N reinas.

Backtracking. 14

Backtracking. 15

2.1 Problema de las n reinas.Representación de la información:• Debe permitir interpretar fácilmente la solución: x:INTEGER[1..n] {x[i]=columna de la reina i en i-ésima fila}

Evaluación del predicado acotador:• Utilizaremos una función buenSitio que devuelva el

valor verdad si la k-ésima reina se puede colocar en el valor x[k], es decir, si está en distinta columna y diagonal que las k-1 reinas anteriores.

• Dos reinas están en la misma diagonal si tienen el mismo valor de “fila+columna”, mientras que están en la misma diagonal si tienen el mismo valor de “fila-columna”.( f 1 c1 f 2 c2) ( f 1 c1 f 2 c2)

(c1 -c2 f 1 f 2) (c1 c2 f 2 f 1) c1 -c2| f 1 f 2|

Backtracking. 16

2.1 Problema de las n reinas.

SUBPROGRAMA colocarReinas(IN k:INTEGER, OUT solucion:INTEGER[1..N]):void

VAR i:INTEGER;

BEGINFOR i IN 1..N DO

BEGINsolucion[k]=i;IF buenSitio(k,solucion) THEN

IF (k==n) THEN escribir(solucion);

ELSE colocarReinas(k+1,solucion);

ENDEND;...colocarReinas(1,solucion);...

Backtracking. 17

2.1 Problema de las n reinas.SUBPROGRAMA buenSitio(IN k:INTEGER; IN x:INTEGER[1..N]):BOOLEAN{devuelve verdad si y sólo si se puede colocar una reina en la fila k y columna x[k],

habiendo sido colocadas ya las k-1 reinas anteriores}VAR

i:INTEGER; amenaza:BOOLEAN;

BEGINi=1; amenaza=FALSE;WHILE ((i<k) ^ ¬ amenaza) DO

BEGIN

IF ((x[i]==x[k]) abs(x[i]-x[k])==abs(i-k)) THEN amenaza=TRUE;

ELSE i=i+1;

 END

return ¬ amenaza;END;