Académique Documents
Professionnel Documents
Culture Documents
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
ti
i 1
1 2 3 4 5 6 7 8
1
2
3
4
5
6
7
8
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)
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):
Backtracking :
bsqueda primero en
profundidad (DFS) en un rbol y con
deteccin de soluciones parciales no
completables (poda)
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).
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
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
Bsqueda con retroceso Pg. 12
El problema de la suma
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.
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.
El problema de la suma
de subconjuntos
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
El problema de la suma
de subconjuntos
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
El problema de la suma
de subconjuntos
El problema de la suma
de subconjuntos
algoritmosumasub(ents,k,r:entero;
algoritmosumasub(ents,k,r:entero;
entsalX:vector[1..n]denat)
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
El problema de la suma
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 ]
El problema de la suma
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
x[4]=0
15,5,33
x[5]=1
0,4,46
x[4]=0
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
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
x[3]=1
x[3]=
3
x[3]
=2
Coloreado de grafos
algoritmom_col(entk:entero;
algoritmom_col(entk:entero;
entsalX:vector[1..n]denat)
entsalX:vector[1..n]denat)
{Seusaunavariableglobalgdetipografo.}
{Seusaunavariableglobalgdetipografo.}
parav:=1..mhacer
parav:=1..mhacer
X[k]:=v
X[k]:=v
sicompletable(X,k)entonces
sicompletable(X,k)entonces
sik=nentoncesescribir(X)
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
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)
Ciclos hamiltonianos
viV, i=1,,n+1,
(vi,vi+1)A, i=1,,n,
v1=vn+1,
Ciclos hamiltonianos
Ejemplos:
1
Hamiltoniano: 1-2-8-7-6-5-4-3-1
Ciclos hamiltonianos
Ciclos hamiltonianos
Grafo: matriz de adyacencias (slo
necesitaremos saber si un arco existe o no)
solucin: vector de vrtices.
algoritmohamiltoniano(entk:entero;
algoritmohamiltoniano(entk:entero;
entsalX:vector[1..n]denat)
entsalX:vector[1..n]denat)
{Seusaunavariableglobalgdetipografo.}
{Seusaunavariableglobalgdetipografo.}
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);
Bsqueda con retroceso Pg. 27
Atravesar un laberinto
Problema:
Nos encontramos en una entrada de un
laberinto y debemos intentar atravesarlo.
Atravesar un laberinto
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
Atravesar un laberinto
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;
funcionHayCamino(entx,y:entero;
entsallab:laberinto)
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)}
Atravesar un laberinto
funcionHayCamino(entx,y:entero;
funcionHayCamino(entx,y:entero;
entsallab:laberinto)
entsallab:laberinto)
{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
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
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
Backtracking genrico
para problemas de
optimizacin
algoritmoBackTracking(entk:entero;
algoritmoBackTracking(entk:entero;
entsalX:vector[1..n]devalor)
entsalX:vector[1..n]devalor)
{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
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
N- reinas
algoritmonreinas(entk:entero;
algoritmonreinas(entk:entero;
entL:dominios;
entL:dominios;
entsalX:vector[1..n]denat)
entsalX:vector[1..n]denat)
{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
sik=nentoncesescribir(X)
sik=nentoncesescribir(X)
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)
variablesb:booleano;j:entero
variablesb:booleano;j:entero
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