Vuelta atrás o Backtracking

1. Método general.

2. Análisis de tiempos de ejecución.

3. Ejemplos de aplicación.

3.1. Problema de las 8 reinas.

3.2. Problema de la mochila 0/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 se puede añadir un nuevo elemento a la solución xk+1, se genera y se avanza al nivel k+1.

Método general

• Si no, se prueban otros valores de xk.

• Si no existe ningún 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.

Método general• Posibilidad 1) Árbol binario: 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: En cada nodo llevamos el valor de la suma hasta

ese punto. Si el valor es mayor que 20: retroceder al nivel anterior.

Árbol de soluciones 1

Método general• Posibilidad 2) Árbol combinatorio: En cada nivel i decidir qué elemento se

añade (1, 2 o 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.• ¿Cómo será la eficiencia del algoritmo? Depende del número de

nodos.

k=1

k=2

k=3

1 3

2

3 5

4

3

32

7

63

31

21

8

0

13 11

20 18

7

24

Método general• Esquema general (sin recursividad). Suponiendo que existe

al menos una solución y que queremos obtener una cualquiera.

Backtracking (var s: array [1.. Max_nivel] of tipo)nivel = 1fin = falserepetir s[nivel] = Generar (nivel, s) si Solución (nivel, s)

fin = true en otro caso si Criterio (nivel, s)

nivel = nivel + 1 en otro caso mientras no MasHermanos (nivel, s)

Retroceder (nivel, s)hasta fin=true

Método general• Variables:

– s: Almacena la solución (un array, desde 1 hasta el nº máximo de niveles).

– nivel: Indica el nivel actual en el que se encuentra el algoritmo.– fin: Valdrá true cuando hayamos encontrado alguna solución.

• Funciones:– Generar (nivel, s): Genera el siguiente hermano (o el primero)

para el nivel actual. Devuelve el siguiente valor a añadir a la solución parcial actual (depende de la solución parcial y del nivel).

– Solución (nivel, s): Comprueba si la solución (s[1], ..., s[nivel]) es una solución válida para el problema.

– Criterio (nivel, s): Comprueba si a partir de (s[1], ..., s[nivel]) se puede alcanzar una solución válida, o si se puede mejorar la actual. En otro caso se rechazarán todos los descendientes.

Método general• Funciones:

– MasHermanos (nivel, s): Devuelve verdad si hay más hermanos del nodo actual que todavía no han sido generados.

– Retroceder (nivel, s): Retrocede un nivel en el árbol de soluciones. Disminuye en 1 el valor de nivel, y posiblemente tendrá que actualizar la solución actual, quitando los elementos retrocedidos.

• ¿Cómo serían estas funciones en los ejemplos anteriores?• Otros posibles casos de problemas:

1) No está garantizado que exista una solución, puede existir alguna o no.

2) Queremos obtener todas las soluciones, no sólo una.

3) El problema es de optimización. De todas las soluciones posibles queremos aquella que maximice (o minimice) una función objetivo.

Análisis de tiempos de ejecución• El tiempo de ejecución depende del número de nodos generados y del

tiempo requerido para cada nodo, que viene dado por el coste de las funciones.

• Suponiendo que una solución sea de la forma: (x1, x2, ..., xn), en el peor caso se generarán todas las posibles combinaciones para cada xi.

• Si el número de posibles valores para cada xi es mi, entonces se generan:m1 nodos en el nivel 1m1·m2 nodos en el nivel 2 ... ....m1·m2· ... ·mn nodos en el nivel n

• Ejemplo: para el problema de la suma de subconjuntos mi = 2. El número de nodos generados es:

t(n) = 2 + 22 + 23 + ... + 2n = 2n+1 - 2• Ejemplo: calcular todas las permutaciones de (1, 2, ..., n). En el nivel 1

tenemos n posibilidades, en el nivel 2 n-1, ..., en el nivel n una posibilidad.

t(n) = n + n·(n-1) + n·(n-1)·(n-2) + ... + n! O(n!)• En general tendremos tiempos con órdenes de complejidad factoriales o

exponenciales.

Problema de las n reinas

• Problema: Dado un tablero de ajedrez de tamaño nxn, encontrar una forma (o todas) de colocar n reinas, sin que ninguna de ellas pueda comerse a otra.

• Solución 1: Probar todas las posiciones posibles y para cada una comprobar si es válida. Para tamaño 8: 4.4261165.368 posibilidades.

• Solución 2: Colocar cada reina en cada fila. Una solución será un array de 1..8. Para cada reina se probarán cada una de las 8 columnas. Habrá que probar: 88 = 161777.216 posibilidades.

• Solución 3: No colocar dos reinas en una misma columna. La solución será una permutación de los números (1, 2, ..., 8): 8! = 40.320 posibilidad.

• Error: No se comprueba si la situación es correcta hasta el final.

Problema de las n reinas

Solución con backtracking.

• Características: Puede existir solución o no. No es un problema de optimización. Suponemos que buscamos todas las soluciones.

• Representación.– Array solución: s: array [1..8] of 0..8.– s[i] = j. La reina de la fila i está en la columna j.

• Recorrido con backtracking: En cada nivel i, probar las formas de colocar la reina de la fila i, desde la columna 1 hasta la 8.

• La posición será válida (podemos avanzar de nivel) si la reina i no está en la misma columna o diagonal que alguna de las reinas anteriores.

Problema de las n reinasFunciones:

– Generar (nivel, s). Probar primero la posición 1, luego la 2, ..., hasta la 8.

– MasHermanos (nivel, s). Cierto si s[nivel] es menor que 8.

– Criterio (nivel, s). Comprobar si la reina de la posición s[nivel] no se come a las anteriores (1, 2, ..., nivel-1).

– Solución (nivel, s). Cierto si el nodo es una hoja (nivel = n) y se cumple Criterio.

– Retroceder (nivel, s). Quitar la reina de la posición nivel. s[nivel]:= 0 (valor de inicialización).

Problema de las n reinasNReinasBacktracking (var s: array [1.. n] of integer)

nivel = 1s[1] = 0repetir s[nivel] = s[nivel] + 1 mientras (s[nivel] n) y no Criterio (nivel, s)

s[nivel] = s[nivel] + 1 si (nivel=n) y (s[nivel] n)

MostrarSolucion (s) en otro caso si (s[nivel] n)

nivel = nivel + 1s[nivel] = 0

en otro casonivel = nivel -1

hasta nivel = 0

Criterio (nivel: 0..n; s: array [1.. n] of integer) : booleanpara i = 1,2,...,nivel-1 si (s[nivel]=s[i]) o |s[i] - s[nivel]| = |i - nivel|

Devolver falseDevolver true

Problema de las n reinas• Ejemplo. N= 4.

1

X

2

X

4 X

X

3 X

X

5 X

X

X

7 X

X

8 X

X

X

9 X

X X

X

6

Problema de las n reinas• Evaluación de la eficiencia. La evaluación es compleja, ya que el

tiempo de ejecución en cada nodo no es constante y el número de nodos generado es difícil de predecir.– El tiempo de ejecución de la función Criterio depende del nivel. Para

nivel i, el número de comprobaciones es (i-1). Está en O(i). Se puede hacer constante.

– Número de nodos, en el peor caso:• Nivel 0: 1• Nivel 1: n/2 0·n/2 Comprobaciones• Nivel 2: (n/2)(n-1) 1·(n/2)(n-1) “• ....• Nivel n: n!/2 (n-1)·n!/2 “

• La cota superior está muy alejada del número real de nodos generados.

• Ejemplo. Para n = 4. Número de nodos en el peor caso = 33. Número de nodos generados realmente = 9.

Problema de las n reinas

• Además, en cada nodo (excepto en las hojas) se comprueban 4 posibles descendientes. Este es el número de veces que se ejecutan las funciones Criterio y Genera (s[nivel] = s[nivel] + 1).

• Solución: Estimación de la eficiencia por probabilidad. Hacemos un cálculo aproximado del número de nodos esperado.

• Estimación de la eficiencia por probabilidad.– Generamos varias permutaciones de (1, 2, .., n), de forma

aleatoria.– Para cada una calcular el nivel al que llegaría (aplicando

la función Criterio), y el número de nodos máximo para ese nivel.

– Hacer una media del número de nodos.

• Problema: maximizar sujeto a con xi= 0, 1

siendo vi = beneficio del objeto i; wi = peso de i; M capacidad máxima.

• Características del problema:– Es un problema de optimización (maximización).– Sólo nos interesa una solución, la óptima.– Existirá al menos una solución (no incluir ningún objeto).

• Diseño de la solución con backtracking:

– Representación de la solución: Una solución será de la forma (x1, x2, ..., xn), con xi= 0, 1. Se generará un árbol binario de soluciones.

– En cada nivel i, probamos la posibilidad de incluir o no el objeto i.

Problema de la mochila 0/1

n

iii vx

1

Mwxn

iii

1

x1

x2

x3

10 1

5

2

3 6

4 87010

10

112

9

10 13

11 1514010

10

1

Problema de la mochila 0/1• Para calcular el peso y el beneficio en cada nodo podemos usar

variables locales w_act, v_act que guardarán el peso y el beneficio acumulado.

• El array de soluciones será s: array [1..n] of –1,0,1.– s[i] = 1, 0. Se añade o no se añade el objeto i.– s[i] = -1. No se ha considerado el objeto i (es el valor de

inicialización).• Al ser un problema de optimización no acabamos hasta haber

recorrido todos los nodos. Acabar cuando nivel = 0 (volvemos al nodo raíz).

• En cada momento llevamos la mejor solución hasta un nodo. Si encontramos una solución nueva, comprobar si es mejor que la solución actual.

• Variable v_max, con el valor de la mejor solución hasta este nodo y s_max con los objetos que la componen.

si Solución (nivel, s) si v_act > v_max

v_max = v_acts_max = s

Problema de la mochila 0/1• Generar (nivel, s). Probar los valores 0 y 1.

Si s[nivel]=-1 Devolver 0

en otro caso w_act = w_act + w[nivel]

v_act = v_act + v[nivel] Devolver 1

• Solución (nivel, s). Indica los nodos hoja que cumplen la restricción de peso.

Devolver (nivel=n) y (w_act M)• Criterio (nivel, s). Indicará si se cumple la restricción de peso y

no estamos en el último nivel.Devolver (nivel<n) y (w _act M)

• MasHermanos (nivel, s).Devolver s[nivel] 1

• Retroceder (nivel, s).w_act = w_act - s[nivel]*w[nivel]v_act = v_act - s[nivel]*v[nivel]s[nivel] = -1nivel = nivel - 1

Problema de la mochila 0/1• Orden de complejidad del algoritmo: Número de nodos generado=

2n+1-1. El algoritmo es de O(2n).

• Problema: En el ejemplo, se generan todos los nodos posibles. La función Criterio es siempre cierta (excepto para algunos nodos hoja).

• Solución: Intentar eliminar algunos nodos del árbol de soluciones, con una función Criterio más restrictiva.

– Para cada nodo, hacer una estimación del máximo beneficio que se podría obtener a partir del mismo.

– Si es menor que el mayor beneficio de una solución anterior (v_max) entonces rechazar ese nodo y sus descendientes.

• La estimación del beneficio para el nivel y nodo actual será:

v_estimado = v_act + Estimacion (k + 1, M - w_act)

• Estimacion (k, Q): Estimar una cota superior para el problema de la mochila 0/1, usando los objetos k..n, con capacidad máxima Q.

Problema de la mochila 0/1• Idea: el resultado del problema de la mochila (no 0/1) es una cota

superior válida para el problema de la mochila 0/1.• Estimacion (k, Q): Aplicar el algoritmo voraz para el problema de

la mochila, con los elementos de k..n. Si los beneficios son enteros, nos podemos quedar con la parte entera del resultado anterior.

• Ejemplo. n = 4; M = 7; v = (2, 3, 4, 5) w = (1, 2, 3, 4)

Problema de la mochila 0/1

• Función Criterio (nivel, s, v_act, w_act, v_max).Si (w _act > M) o (nivel=n) Devolver Falseen otro caso v_estimado= v_act + MochilaVoraz (nivel+1, M -

w_act) Devolver v_estimado > v_max

• Modificación en el algoritmo de backtracking. ...

mientras no MasHermanos (nivel, s) o no Criterio (nivel, s, v_act, w_act, v_max)

Retroceder (nivel, s); ...

• Se eliminan nodos a costa de aumentar el tiempo de ejecución de la función Criterio. ¿Cuál será el tiempo de ejecución total?

Problema de la mochila 0/1• Suponemos todos los objetos ordenados por vi/wi.• Tiempo de la función Criterio en el nivel i (en el peor caso) = 1

+ Tiempo de la función MochilaVoraz = 1 + n - i.• Idea intuitiva. Tiempo en el peor caso (suponiendo todos los

nodos): Número de nodos O(2n) * Tiempo de cada nodo (función criterio) O(n).

• ¿Tiempo: O(n·2n)?

• Conclusiones:– El cálculo “intuitivo” del tiempo no es correcto (no es válido

O(n·2n)).– El orden de complejidad no varía, O(2n), aunque el tiempo

es 2 veces mayor. – Si se podan más de la mitad de los nodos podemos esperar

una mejora.

422·222)1()1(2)( 1

111

nininnt nn

i

in

i

in

i

i

Problema de la mochila 0/1

Posible modificación 1• Para cada nodo, generar primero el valor 1 y luego el valor 0 (en

lugar de primero 0 y luego 1).• Ejemplo anterior.

• Idea: es de esperar que la solución de la mochila 0/1 sea “parecida” a la de la mochila no 0/1. Si ordenamos los objetos por v i/wi entonces tendremos una solución con 1 en las primeras posiciones.

Problema de la mochila 0/1

Posible modificación 2• Utilizar una representación de la solución como un conjunto de los

elementos incluidos. S = (s1, s2, ..., sm) donde mn y si {1, 2, ..., n}.

• ¿Cómo generar unárbol de este tipo?

• ¿Cuál es el númerode nodos máximo?

Árbol combinatorio