Backtracking 2

Bsqueda con retroceso
Introduccin
El problema de las ocho reinas
El problema de la suma de
subconjuntos
Coloreado de grafos
Ciclos hamiltonianos
Atravesar un laberinto
El problema de la mochila 0-1
Bsqueda con retroceso Pg. 1
Bsqueda con retroceso:

Introduccin
Problemas que consideraremos:

Problemas de Decisin: Bsqueda de las
soluciones que satisfacen ciertas
restricciones.
Problemas de Optimizacin: Bsqueda
de la mejor solucin en base a una funcin
objetivo.
Cada solucin es el resultado de una
secuencia de decisiones.
En algunos problemas de este tipo se
conoce un criterio ptimo de seleccin en
cada decisin:
tcnica voraz.
En otros problemas se cumple el principio
de optimalidad de Bellman y se puede
aplicar la tcnica de la programacin
dinmica.
Existen otros problemas en los que no hay
ms remedio que buscar.

Introduccin
Planteamiento del problema:

Se trata de hallar todas las soluciones que
satisfagan un predicado Sol.
La solucin debe poder expresarse como una
tupla (x1,,xn) donde cada xi pertenece a un
dominio Ci.
Si |Ci|=ti, entonces hay
ti
i 1
n-tuplas candidatas para satisfacer Sol.

Mtodo de fuerza bruta: examinar las t ntuplas y seleccionar las que satisfacen Sol.
Bsqueda con retroceso (backtracking, en
ingls): formar cada tupla de manera
progresiva,
elemento a elemento, comprobando para
cada
elemento xi aadido a la tupla que (x1,,xi)
puede conducir a una tupla completa
satisfactoria.

Introduccin
Deben existir unas funciones objetivo parciales o
predicados acotadores Completable(x1,,xi).
Dicen si (x1,,xi) puede conducir a una solucin.
Diferencia entre fuerza bruta y bsqueda con
retroceso:
si se comprueba que (x1,,xi) no puede
conducir a ninguna solucin, se evita formar
las ti+1tn tuplas que comienzan por
(x1,,xi)
Para saber si una n-tupla es solucin, suele
haber dos tipos de restricciones:
explcitas: describen el conjunto C de
i
valores que puede tomar xi (todas las tuplas
que satisfacen estas restricciones definen un
espacio de soluciones posibles);
implcitas: describen las relaciones que
deben cumplirse entre los xi (qu soluciones
posibles satisfacen el predicado objetivo Sol).

Introduccin
Ejemplo: el problema de las ocho

reinas
El problema consiste en colocar ocho
reinas en un tablero de ajedrez sin que se
den jaque (dos reinas se dan jaque si
comparten fila, columna o diagonal).
1 2 3 4 5 6 7 8
1
2
3
4
5
6
7
8

Introduccin
64
Formulacin 1: 4.426.165.368
8
Formulacin 2: Puesto que no puede
haber ms de una reina por fila, podemos
replantear el problema como:
colocar una reina en cada fila del tablero
de forma que no se den jaque.
En este caso, para ver si dos reinas se dan
jaque basta con ver si comparten columna
o diagonal.
Por lo tanto, toda solucin del problema
puede representarse con una 8-tupla (x1,
,x8) en la que xi es la columna en la que
se coloca la reina que est en la fila i del
tablero.
El espacio de soluciones consta de
88 8-tuplas (16.777.216 8-tuplas)
Formulacin 3: Puesto que no puede
haber ms de una reina por columna, slo
hace falta que consideremos las 8-tuplas
(x1,,x8) que sean permutaciones de
(1,2,...,8)
El espacio de soluciones consta de
8! 8-tuplas (40.320 8-tuplas)

Introduccin
Volviendo al planteamiento
general:
Para facilitar la bsqueda, se adopta una
organizacin en rbol del espacio de
soluciones.
En el ejemplo, con la 2
formulacin y para el problema de
las cuatro reinas (en un tablero
44):

Introduccin
algoritmoBackTracking(entk:entero;
entsalX:vector[1..n]devalor)
{Pre:X[1..k1]escompletable}
{Pre:X[1..k1]escompletable}
variablev:valor
variablev:valor
paratodovenC
paratodovenCiihacer
hacer
X[k]:=v;
X[k]:=v;
sicompletable(X,k)entonces
siSol(X,k)entonces
siSol(X,k)entonces
guardar(X,k)
guardar(X,k)
fsi;
fsi;
sik<nentonces
sik<nentonces
BackTracking(k+1,X)
BackTracking(k+1,X)
fsi;
fsi;
fsi
fsi
fpara
fpara
La llamada inicial es:

...
...
BackTracking(1,X);
BackTracking(1,X);
...
...

Introduccin
Ntese que el rbol no se construye

explcitamente sino implcitamente
mediante las llamadas recursivas del
algoritmo de bsqueda.
El algoritmo no hace llamadas

recursivas cuando:
k = n+1, o cuando
el nodo generado no es completable (PODA).
Backtracking :
bsqueda primero en
profundidad (DFS) en un rbol y con
deteccin de soluciones parciales no
completables (poda)
El algoritmo anterior halla todas las

soluciones y adems stas pueden
ser de longitud variable (< n+1).

Introduccin
Variantes:
Limitar el nmero de soluciones a una sola
aadiendo un parmetro booleano de
salida que indique si se ha encontrado una
solucin.
Forzar a que slo los nodos hoja puedan
significar solucin (realizando la recursin
slo si no se ha encontrado un nodo
solucin):
Resolver problemas de optimizacin:
adems de la solucin actual en
construccin hay que guardar la mejor
solucin encontrada hasta el momento.
Se mejora la eficiencia de la bsqueda si el
predicado completable permiten eliminar
los
nodos de los que se sabe que no pueden
llevar a una solucin mejor que la ahora
disponible (poda; mtodos de
ramificacin y acotacin).

Introduccin
Sobre la eficiencia:
Depende de:
el nmero de nodos del rbol de
bsqueda que se visitan: v(n)
el trabajo realizado en cada nodo
(normalmente un polinomio): p(n)
Coste de: Completable y Sol
en general: O(p(n) v(n))
Mejoras:
Si se consigue que los predicados
acotadores reduzcan mucho el nmero
de nodos generados (aunque un buen
predicado acotador precisa mucho
tiempo de evaluacin; compromiso)
Si lo reducen a un solo nodo
generado
(solucin voraz): O(p(n) n) nodos
a generar en total
Normalmente:
O(p(n) 2n) O(p(n) n!)
El problema de la suma
de subconjuntos
Problema:
Dados un conjunto W={w1,,wn} de n
nmeros positivos y otro nmero positivo M,
se trata de encontrar todos los subconjuntos
de W cuya suma es M.
Ejemplo: si W={11,13,24,7} y M=31,
entonces la solucin es {11,13,7} y {24,7}.
Primera representacin de la
solucin:
La solucin puede representarse
simplemente con los ndices de los
elementos de W.
En el ejemplo: (1,2,4) y (3,4).
En general, todas las soluciones son k-tuplas
(x1,x2,,xk), 0<k<n+1.
Restricciones sobre las soluciones:
Explcitas:
xi j j es un entero y1 j n
i j xi xj
Implicitas:
k
wxi M
i1
xi xi 1, 1 i n
de subconjuntos
Segunda representacin de la
solucin:
Cada solucin puede representarse con una
n-tupla (x1,x2,,xn), tal que xi {0,1}, 1in,
de forma que:
x = 0 si w no se elige y
i
i
xi = 1 si wi se elige.
En el ejemplo anterior: (1,1,0,1) y (0,0,1,1).
Conclusin:
Pueden existir varias formas de formular un
problema, con distintas representaciones de
las soluciones (aunque siempre verificando
stas un conjunto de restricciones explcitas e
implcitas).
En el problema que consideramos, ambas
representaciones nos llevan a un espacio de
estados que consta de 2n tuplas.
de subconjuntos
Arbol del espacio de soluciones

(n=4) para la primera
representacin (tuplas de tamao
variable):
Un arco del nivel i al nivel i+1 representa
un
valor para xi.
El espacio de soluciones est definido por
1
todos
x = cualquier
x =1la raz hasta
los caminos desde
x =2
x= 4
hoja del rbol.
3
4
5
1
x2 = x2 =
x2=2
x2 =
3
4
x2 = x =
4
2
6 3
74
8
11
9 10
x3 = x3 =
4
4
x3 =
3
12 13
14
x4 =
4
16
x3 =
4
15
de subconjuntos
Arbol del espacio de soluciones

(n=4) para la segunda
representacin (tuplas de tamao
fijo):
Los arcos del nivel i al nivel i+1 estn
etiquetados con el valor de xi (1 0).
Todos los caminos desde la raz a una hoja
definen el espacio de soluciones (24 hojas
que representan las1 16 posibles 4-tuplas).
x1=1
x1=0
x2=1
x2=0
18
x3=1
26
x4=1
30
x2=1
19
x3=0
27
x3=1
20
x2=0
x3=0
21
x3=1
12
x3=0
x3=1
13
x3=0
x4=0
x4=0
x4=0
x4=0
x4=0
x4=0
x4=0
x4=0
x4=1
x4=1
x4=1
x4=1
x4=1
x4=1
x4=1
31
28
29
24
25
22
23
16
17
14
15
10
11
de subconjuntos
Estudiemos una solucin de

bsqueda con retroceso basada en
la segunda representacin (tuplas
de tamao fijo).
El elemento x[i] del vector solucin toma el
valor 1 0 dependiendo de si el nmero
w[i] se
incluye o no en la solucin.
Funcin acotadora (completable):
La tupla (x[1],x[k]) slo puede conducir a
una solucin si:
Adems la tupla (x[1],x[k]) no

puede conducir a una solucin si:
Es decir, una funcin acotadora es:
de subconjuntos
algoritmosumasub(ents,k,r:entero;
algoritmosumasub(ents,k,r:entero;
entsalX:vector[1..n]denat)
{k:siguientevariableadecidir
{k:siguientevariableadecidir
Losw[j]estnenordencreciente
Losw[j]estnenordencreciente
k -1
j=1
j=k
s=w[j]*x[j];r=w[j]
s=w[j]*x[j];r=w[j]
n
i =1
s+w[k]
s+w[k]M;s+w[i]M
M;s+w[i]M
}
}
X[k]:=1;
X[k]:=1;
sis+w[k]=Mentoncesescribir(X[1..k])
sis+w[k]=Mentoncesescribir(X[1..k])
sino
sino
sis+w[k]+w[k+1]Mentonces
sis+w[k]+w[k+1]Mentonces
sumasub(s+w[k],k+1,rw[k],X)
sumasub(s+w[k],k+1,rw[k],X)
fsi
fsi
fsi
fsi
si(s+rw[k]
si(s+rw[k]
M)y(s+w[k+1]M)entonces
M)y(s+w[k+1]M)entonces
X[k]:=0;
X[k]:=0;
sumasub(s,k+1,rw[k],X)
sumasub(s,k+1,rw[k],X)
fsi
fsi
fin
fin
de subconjuntos
La llamada inicial es:
...
...
n
sumasub(0,1,w[i])
i =1
sumasub(0,1,w[i])
...
...
Ntese que el algoritmo evita calcular
k
i =1w[i ]x[i ]
n
i =k+1w[i ]
cada vez guardando esos valores en s y r.

A esto se le llama MARCAJE.
Coste:
con marcaje: O(2n)
sin marcaje: O(n 2n)
de subconjuntos
Ejemplo: n=6, M=30,
W=(5,10,12,13,15,18)
Los rectngulos son s,k,r en cada llamada.
A=(1,1,0,0,1); B=(1,0,1,1);
C=(0,0,1,0,0,1).
Se construyen 26 nodos (del total de 271=127)
0,1,73
x[1]=1
5,2,68
0,2,68
x[2]=0
x[2]=1
5,3,58
15,3,58
x[3]=1
x[3]=0 x[3]=1
10,3,58
0,3,58
x[3]=0
27,4,46 15,4,46 17,4,46 5,4,46 10,4,46 12,4,46

x[4]=1
x[4]=0
15,5,33
x[5]=1
0,4,46
x[4]=0
5,5,33 10,5,33 12,5,33 13,5,33 0,5,33

x[5]=1
20,6,18
12,6,18 13,6,18
Coloreado de grafos
Problema de decisin:
Dados un grafo G y un nmero entero
positivo m, es G m-coloreable?
Es decir, se puede pintar con colores los
nodos de G de modo que no haya dos
vrtices
adyacentes con el mismo color y se usen
slo m colores?
Problema de optimizacin:
Dado un grafo G, cul es su nmero
cromtico?
Es decir, cul es el menor nmero m de
colores con el que se puede colorear G?
Coloreado de grafos
Un subproblema muy famoso:

Dado un mapa, pueden pintarse sus regiones
(autonomas, pases, o lo que sea) de tal forma
que no haya dos regiones adyacentes de igual
color y no se empleen ms de 4 colores?
1
5
4
2
3
4
5
Cada regin se modela con un nodo y si dos
regiones son adyacentes sus correspondientes
nodos se conectan con un arco.
As se obtiene siempre un grafo plano (puede
dibujarse en un plano sin cruzar sus arcos).
El mapa de la figura requiere 4 colores.
Desde hace muchos aos se saba que 5 colores
eran suficientes para pintar cualquier mapa,
pero no se haba encontrado ningn mapa que
requiriera ms de 4.
Recientemente, despus de varios cientos de
aos, se ha demostrado que 4 colores siempre
son suficientes.
Coloreado de grafos
El problema que consideraremos

aqu:
Dado un grafo cualquiera, determinar
todas las formas posibles en las que
puede pintarse
utilizando no ms de m colores.
Representacin elegida: matriz de
adyacencias.
Justificacin de la eleccin: slo
necesitaremos saber si un arco existe o no.
Representacin de los colores: enteros de
1 a m.
Representacin
de la solucin: vector
x[1]=1
x[1]=3 de
x[1]=2
colores.
Espacio de estados para n=3 y m=3.
x[2]=1
x[2]=3
x[2]=2
x[3]=1
x[3]=
3
x[3]
=2
Coloreado de grafos
algoritmom_col(entk:entero;
algoritmom_col(entk:entero;
{Seusaunavariableglobalgdetipografo.}
parav:=1..mhacer
parav:=1..mhacer
X[k]:=v
X[k]:=v
sik=nentoncesescribir(X)
sinom_col(k+1,X)
sinom_col(k+1,X)
fsi
fsi
fsi
fsi
fpara
fpara
fin
fin
funcionCompletable(entsalx:sol;
funcionCompletable(entsalx:sol;
entk:entero)
entk:entero)
variablesb:booleano;j:entero
b:=verdad;j:=1;
b:=verdad;j:=1;
mientras(j<k)bhacer
mientras(j<k)bhacer
sig[k,j]y(x[k]=x[j])entonces
sig[k,j]y(x[k]=x[j])entonces
b:=falso
b:=falso
sinoj:=j+1
sinoj:=j+1
fsi
fsi
fmientras
fmientras
retorna(b)
retorna(b)
Problema: encontrar todos los ciclos

hamiltonianos de un grafo.
Sea G=(V,A) un grafo no dirigido, conexo con
n vrtices.
Un ciclo hamiltoniano es un camino que
visita
una vez cada vrtice y vuelve al vrtice
inicial.
Es decir, v1v2vn+1 tal que:
viV, i=1,,n+1,
(vi,vi+1)A, i=1,,n,
v1=vn+1,
vivj, i,j=1,,n tales que i j.
No se conoce un algoritmo eficiente

para resolver el problema.
Ntese la relacin entre el problema

del clculo de un hamiltoniano y el
problema del viajante de comercio
Ejemplos:
1
Hamiltoniano: 1-2-8-7-6-5-4-3-1
No contiene ningn hamiltoniano.
Solucin de bsqueda con

retroceso:
En el vector solucin (x1,,xn), xi representa
el vrtice visitado en i-simo lugar en el
ciclo.
Clculo de los posibles valores para xk si x1,
,xk-1 ya tienen valores asignados:
k=1: x1 puede ser cualquiera de los n

vrtices, pero para evitar escribir el
mismo ciclo n veces obligamos que
x1=1;
1<k<n: xk puede ser cualquier vrtice

distinto de x1,,xk-1 y conectado por un
arco con xk-1.
k=n: xn slo puede ser el vrtice que

queda sin visitar y debe estar conectado
por sendos arcos con x1 y xn-1.
Grafo: matriz de adyacencias (slo
necesitaremos saber si un arco existe o no)
solucin: vector de vrtices.
algoritmohamiltoniano(entk:entero;
algoritmohamiltoniano(entk:entero;
parav:=1..nhacer
parav:=1..nhacer
X[k]:=v;
X[k]:=v;
sicompletable(k,X)entonces
sicompletable(k,X)entonces
sik=nentonces
sik=nentonces
escribir(X)
escribir(X)
sinohamiltoniano(k+1,X)
sinohamiltoniano(k+1,X)
fsi
fsi
fsi
fsi
fpara
fpara
funcioncompletable(entk:entero;
funcioncompletable(entk:entero;
entX:vector[1..n]denat)
entX:vector[1..n]denat)
b:=g[X[k1],X[k]];
b:=g[X[k1],X[k]];
parai:=1..k1mientrasbhacer
parai:=1..k1mientrasbhacer
siX[i]=X[k]entoncesb:=falsofsi
siX[i]=X[k]entoncesb:=falsofsi
fpara
fpara
sik=ng[X[n],X[1]]entonces
sik=ng[X[n],X[1]]entonces
b:=falso
b:=falso
fsi
fsi
retornab
retornab
x[1]:=1;
x[1]:=1;
hamiltoniano(2,x);
hamiltoniano(2,x);
Problema:
Nos encontramos en una entrada de un
laberinto y debemos intentar atravesarlo.
Representacin: matriz de dimensin nn

de casillas marcadas como libre u ocupada
por una pared.
Es posible pasar de una casilla a otra
movindose slamente en vertical u
horizontal.
Se debe ir de la casilla (1,1) a la casilla
(n,n).
Disearemos un algoritmo
de bsqueda con retroceso
de forma que se marcar
en la misma matriz del
laberinto un camino
solucin (si existe).
N MN
M
MN
MN M
MN
N MN N
N N MN M
NM
MN M
MN M
N
NM
M
N MN M N
Si por un camino recorrido

se llega a una casilla desde N M N < <
M <<<
la que es imposible
N <<
encontrar una solucin,
hay que volver atrs y
buscar otro camino.
Adems hay que marcar las casillas por

donde ya se ha pasado para evitar meterse
varias veces en el mismo callejn sin salida,
dar vueltas
alrededor de columnas
Estructura de datos:
tipos
tipos
casilla=(libre,pared,camino,imposible)
casilla=(libre,pared,camino,imposible)
laberinto=vector[1..n,1..n]decasilla
laberinto=vector[1..n,1..n]decasilla
Solucin de bsqueda
...
retroceso:
...
HayCamino(1,1,lab)
HayCamino(1,1,lab)
...
...
con
funcionHayCamino(entx,y:entero;
entsallab:laberinto)
{Pre:Hemosencontradouncaminodesde(1,1)
{Pre:Hemosencontradouncaminodesde(1,1)
hasta(x,y).
hasta(x,y).
Post:Devuelveciertossisepuedeextender
Post:Devuelveciertossisepuedeextender
hasta(n,n)}
hasta(n,n)}
{devuelveciertossiexistecamino}
{devuelveciertossiexistecamino}
si(x<1)(x>n)(y<1)(y>n)
si(x<1)(x>n)(y<1)(y>n)
lab[x,y]libreentonces
lab[x,y]libreentonces
devuelvefalso
devuelvefalso
sino
sino
lab[x,y]:=camino;
lab[x,y]:=camino;
si(x=n)(y=n)entonces
si(x=n)(y=n)entonces
escribir(lab);
escribir(lab);
devuelvecierto;
devuelvecierto;
sino
sino
b:=HayCamino(x+1,y,lab)
b:=HayCamino(x+1,y,lab)
HayCamino(x,y+1,lab)
HayCamino(x,y+1,lab)
HayCamino(x1,y,lab)
HayCamino(x1,y,lab)
HayCamino(x,y1,lab);
HayCamino(x,y1,lab);
sibentonces
sibentonces
lab[x,y]:=imposible;
lab[x,y]:=imposible;
fsi
fsi
devuelveb;
devuelveb;
fsi
fsi
fsi
fsi
fin
fin
El problema de la
mochila 0-1
Recordar
Se tienen n objetos y una mochila.
El objeto i tiene peso pi y la inclusin del
objeto i en la mochila produce un beneficio
bi.
El objetivo es llenar la mochila, de
capacidad C, de manera que se maximice
maximizar bi xi
el beneficio.
1i n
sujeto a
pi xi C
1i n
con xi {0,1}, bi 0, pi 0, 1 i n
Es el primer problema de
optimizacin que vamos a resolver
con Backtracking.
El problema de la
mochila 0-1
Tuplas de tamao fijo:
xi=0 si el objeto i-simo no se introduce
xi=1 si el objeto se introduce
1
x1=0
x1=1
17
x2=0
x2=1
x3=0
10
x3=1
x4=0
5
x2=0
x3=0
11
x2=1
18
x3=1
14
x3=0
19
25
x3=1
22
x3=0
26
x3=1
29
x4=1
x4=1
x4=1
x4=1
x4=1
x4=1
x4=1
x4=1
x4=0
x4=0
x4=0
x4=0
x4=0
x4=0
x4=0
6
12
13
15
16
20
21
23
24
27
28
30
31
Elegimos sta ltima representacin.
El problema de la
mochila 0-1
Problema de optimizacin
(maximizacin): Solo nos interesa
la mejor solucin
En todo momento guardamos el
coste de la mejor solucin
encontrada hasta el momento MS
(que es una cota inferior de la
mejor solucin)
Slo buscaremos donde podamos
mejorar respecto a la mejor
solucin (poda basada en la mejor
solucin, PBMS)
El problema de la
mochila 0-1
Formalmente:
Sea X[1..k-1] la asignacin en curso.
Sea ben el beneficio de la mejor solucin
que hemos encontrado en lo que llevamos
de bsqueda (si aun no hemos encontrado
ninguna ben=0)
c(X,k) es el beneficio de la mejor solucin
que se puede obtener extendiendo X[1..k-1]
cota(X,k) es una cota superior de c(X,k).
Es decir, cota(X,k) c(X,k), para todo
X[1..k-1]
Si cota(X,k) ben, entonces hacemos
backtracking (podamos)
cmo calcular cota(X,k) en el problema de
la mochila?
relajar el requisito de integridad en las
decisiones que an no hemos hecho:
xi{0,1}, ki n se sustituye por 0xi 1,
kin
aplicar el algoritmo voraz
El problema de la
mochila 0-1
tipovectReal=vector[1..n]dereal
tipovectReal=vector[1..n]dereal
{Pre:i1..n:peso[i]>0,benef[i]>0,
i1..n1:benef[i]/peso[i]benef[i+1]/peso[i+1]}
funcincota(benef,peso:vectReal;
funcincota(benef,peso:vectReal;
cap,ben:real;k:entero)
cap,ben:real;k:entero)
devuelvereal
devuelvereal
{cap=capacidadanlibredelamochila;
{cap=capacidadanlibredelamochila;
ben=beneficioactual;
ben=beneficioactual;
k=ndicedelprimerobjetoaconsiderar}
k=ndicedelprimerobjetoaconsiderar}
principio
principio
sik>norcap=0.0
sik>norcap=0.0
entoncesdevuelveben
entoncesdevuelveben
sino
sino
sipeso[k]>capentonces
sipeso[k]>capentonces
devben+cap/peso[k]*benef[k]
devben+cap/peso[k]*benef[k]
sino
sino
devcota(benef,peso,cappeso[k],
devcota(benef,peso,cappeso[k],
ben+benef[k],k+1)
ben+benef[k],k+1)
fsi
fsi
fsi
fsi
fin
fin
El problema de la
mochila 0-1
tiposolucin=vector[1..n]de0..1
tiposolucin=vector[1..n]de0..1
{variablesglobales:
{variablesglobales:
benef,peso:vectReal;cap:real}
benef,peso:vectReal;cap:real}
algoritmobsqueda(entsolAct:solucin;
algoritmobsqueda(entsolAct:solucin;
entbenAct,pesAct:real;
entbenAct,pesAct:real;
entk:entero;
entk:entero;
e/ssol:solucin;
e/ssol:solucin;
e/sben:real)
e/sben:real)
parav:=1hasta0hacer
parav:=1hasta0hacer
solAct[k]:=v;
solAct[k]:=v;
benAct:=benAct+v*benef[k];
benAct:=benAct+v*benef[k];
pesAct:=pesAct+v*peso[k];
pesAct:=pesAct+v*peso[k];
sipesActcapben<cota(benef,peso,
sipesActcapben<cota(benef,peso,
cappesAct,benAct,k+1)entonces
cappesAct,benAct,k+1)entonces
sik=nentonces
sik=nentonces
sibenAct>benentonces
sibenAct>benentonces
sol:=solAct;ben:=benAct
sol:=solAct;ben:=benAct
fsi
fsi
sinobsqueda(solAct,benAct,pesAct,
sinobsqueda(solAct,benAct,pesAct,
k+1,sol,ben)
k+1,sol,ben)
fsi
fsi
fsi
fsi
fpara
fpara
fin
fin
El problema de la
mochila 0-1
algoritmomochila01(entbenef,peso:vectReal;
algoritmomochila01(entbenef,peso:vectReal;
entcap:real;
entcap:real;
salsol:solucin;
salsol:solucin;
salben:real)
salben:real)
variablesobj:entero;solAct:solucin
variablesobj:entero;solAct:solucin
principio
principio
ben:=0.0;
ben:=0.0;
bsqueda(solAct,0.0,0.0,1,sol,ben)
bsqueda(solAct,0.0,0.0,1,sol,ben)
fin
fin
Mejora adicional:
encontrar una solucion factible (no
necesariamente ptima) con un algoritmo
voraz. Sea r su coste.
Obviamente r es una cota inferior de la
solucin del problema.
Por lo tanto, podemos inicializar ben:=r
ejercicio: Pensar un algoritmo voraz

que encuentre una solucin factible.
El problema de la
mochila 0-1
Ejemplo:
benef=(11,21,31,33,43,53,55,65)
peso=(1,11,21,23,33,43,45,55)
cap=110
n=8
164.88
1
1
11
1
12
32
56
96
164.66
99
149
101
151
162
0
0
159.79
0
154.88
0
157.11
159.33
0
158
157.63
160.18
139
151
35
65
66
68
106
108
1
0 157.55
0
109
159
161.63
0
1
149
163.81
157.44
160.22
89 162.44
139
1
0
155.11
159.76
33
63
159
ben=159
sol=(1,1,1,0,1,1,0,0)
El problema de la
mochila 0-1
De los 29-1 nodos del espacio de estados,
slo se generaron 33.
Se poda haber reducido a 26 simplemente
sustituyendo la condicin
ben<cota(...)
en el algoritmo bsqueda por:
ben< cota(...)
Backtracking genrico
para problemas de
optimizacin
ahora para problemas de

minimizacin
X[1..k]: asignacin actual (solucin que
estamos tratando de construir)
MejorSol: Mejor solucin encontrada hasta
el momento (se inicializa a Null)
MS: Coste de la mejor solucin encontrada
hasta el momento (es una cota superior de
la solucin ptima). Se inicializa a infinito.
c(X,k): devuelve una cota inferior del
mejor coste que se puede obtener a partir
de la asignacin actual
Si c(X,k) MS, entonces no sirve de nada
seguir con la asignacin actual (podamos,
es decir, hacemos backtracking)
Es decir, slo hacemos llamada recursiva
si: completable(X,k) y c(X,k)<MS
Backtracking genrico
para problemas de
optimizacin
{Pre:X[1..k1]escompletable,
{Pre:X[1..k1]escompletable,
c(X,k1)<MS}
c(X,k1)<MS}
paratodovenC
paratodovenCiihacer
hacer
X[k]:=v;
X[k]:=v;
si(completable(X,k)
si(completable(X,k)
c(X,k)<MS)entonces
c(X,k)<MS)entonces
siSol(X,k)entonces
siSol(X,k)entonces
MejorSol:=X;
MejorSol:=X;
MS:=Coste(X)
MS:=Coste(X)
fsi;
fsi;
sik<nentonces
sik<nentonces
BackTracking(k+1,X)
BackTracking(k+1,X)
fsi;
fsi;
fsi
fsi
fpara
fpara
Mejoras al esquema de
Backtracking
Arboles dinmicos:
Hasta ahora hemos considerado rboles de bsqueda
estticos:
siguiendo cualquier rama nos encontrbamos las
variables en el mismo orden.
recorriendo un nivel de izquierda a derecha nos
encontrbamos los valores en el mismo orden
Arboles dinmicos: ordenes variables
Anticipacin (look ahead):

Cada variable xi guarda la lista de los valores de su
dominio Ci
Cada vez que se asigna un valor a una variable, se
eliminan de todas las variables no asignadas los
valores incompatibles con la asignacin
Si a alguna variable no le quedan valores posibles,
BACKTRACKING
Eliminacin de simetras:
En muchos problemas reales existen simetras que
hacen que varias soluciones sean esencialmente la
misma (via rotaciones, proyecciones,...)
Encontrar la misma solucin varias veces es
ineficiente
Solucin: aadir nuevas restricciones que prohiban
soluciones repetidas
Mejoras al esquema de
Backtracking
Vamos a desarrollar un backtracking para

las n-reinas que introduzca estas mejoras:
X: vector[1..n] de nat
x[i]=0, la columna i, aun no tiene reina
asignada
x[i]= j (j<>0), la reina de la columna i esta
situada en la fila j
tipo dominios es vector[1..n] de lista de nat
Si L es una variable de tipo dominios,
L[i] es la lista de los valores posibles para la
variable x[i]
Inicialmente:
L[i]={1,2,...,n} para i=2..n
L[1]={1,2,..., n/2 } (para eliminar
simetras)
N- reinas
algoritmonreinas(entk:entero;
algoritmonreinas(entk:entero;
entL:dominios;
entL:dominios;
{k:numerodevariablesasignadas,
{k:numerodevariablesasignadas,
X:asignacinactual
X:asignacinactual
L:valorescompatiblesconla
L:valorescompatiblesconla
asignacinactual}
asignacinactual}
L2:=L
L2:=L
i:=Seleccionar_Variable(X,L);{seleccin
i:=Seleccionar_Variable(X,L);{seleccin
arbitraria}
arbitraria}
paravL[i]hacer{ordenarbitrario}
paravL[i]hacer{ordenarbitrario}
X[i]:=v;
X[i]:=v;
sianticipacin(X,i,v,L2)entonces
sianticipacin(X,i,v,L2)entonces
sinonreinas(k+1,L2,X)
sinonreinas(k+1,L2,X)
fsi
fsi
fsi
fsi
L2:=L;
L2:=L;
fpara
fpara
X[i]:=0;
X[i]:=0;
fin
fin
N- reinas
funcionanticipacion(entX:sol;
funcionanticipacion(entX:sol;
enti,v:entero;entsalL2:dominios)
enti,v:entero;entsalL2:dominios)
b:=cierto;j:=1;
b:=cierto;j:=1;
mientras(j<n+1)bhacer
mientras(j<n+1)bhacer
siX[j]=0entonces
siX[j]=0entonces
parauL[j]hacer
parauL[j]hacer
siu=v|ij|=|uv|entonces
siu=v|ij|=|uv|entonces
borrar(L[j],v)
borrar(L[j],v)
fpara
fpara
b:=falso
b:=falso
sinoj:=j+1
sinoj:=j+1
fsi
fsi
fmientras
fmientras
retorna(b)
retorna(b)
Para n-reinas:
seleccionar la variable a la que le queden
menos valores
asignar los valores en orden aleatorio

Backtracking 2

Diunggah oleh

Informasi Dokumen

Hak Cipta

Format Tersedia

Bagikan dokumen Ini

Bagikan atau Tanam Dokumen

Opsi Berbagi

Apakah menurut Anda dokumen ini bermanfaat?

Apakah konten ini tidak pantas?

Hak Cipta:

Format Tersedia

Backtracking 2

Diunggah oleh

Hak Cipta:

Format Tersedia

Bsqueda con retroceso

Bsqueda con retroceso Pg. 1

Bsqueda con retroceso:

Problemas que consideraremos:

Bsqueda con retroceso Pg. 2

Bsqueda con retroceso:

Planteamiento del problema:

n-tuplas candidatas para satisfacer Sol.

Bsqueda con retroceso Pg. 3

Bsqueda con retroceso:

Bsqueda con retroceso Pg. 4

Bsqueda con retroceso:

Ejemplo: el problema de las ocho

Bsqueda con retroceso Pg. 5

Bsqueda con retroceso:

Bsqueda con retroceso Pg. 6

Bsqueda con retroceso:

Bsqueda con retroceso Pg. 7

Bsqueda con retroceso:

La llamada inicial es:

Bsqueda con retroceso:

Ntese que el rbol no se construye

El algoritmo no hace llamadas

El algoritmo anterior halla todas las

Bsqueda con retroceso Pg. 9

Bsqueda con retroceso:

Bsqueda con retroceso Pg. 10

Bsqueda con retroceso:

en general: O(p(n) v(n))

Bsqueda con retroceso Pg. 11

En el ejemplo anterior: (1,1,0,1) y (0,0,1,1).

Bsqueda con retroceso Pg. 13

Arbol del espacio de soluciones

Bsqueda con retroceso Pg. 14

Arbol del espacio de soluciones

Bsqueda con retroceso Pg. 15

Estudiemos una solucin de

Adems la tupla (x[1],x[k]) no

Es decir, una funcin acotadora es:

Bsqueda con retroceso Pg. 16

Bsqueda con retroceso Pg. 17

cada vez guardando esos valores en s y r.

sin marcaje: O(n 2n)

Bsqueda con retroceso Pg. 18

27,4,46 15,4,46 17,4,46 5,4,46 10,4,46 12,4,46

5,5,33 10,5,33 12,5,33 13,5,33 0,5,33

Bsqueda con retroceso Pg. 19

Bsqueda con retroceso Pg. 20

Un subproblema muy famoso:

Bsqueda con retroceso Pg. 21

El problema que consideraremos

Bsqueda con retroceso Pg. 22

Bsqueda con retroceso Pg. 23

Problema: encontrar todos los ciclos

vivj, i,j=1,,n tales que i j.

No se conoce un algoritmo eficiente

Ntese la relacin entre el problema

Bsqueda con retroceso Pg. 24

No contiene ningn hamiltoniano.

Bsqueda con retroceso Pg. 25

Solucin de bsqueda con

k=1: x1 puede ser cualquiera de los n

1<k<n: xk puede ser cualquier vrtice

k=n: xn slo puede ser el vrtice que