5-Busqueda Con Retroceso PDF

Bsqueda con retroceso
v
v
v
v
v
v
v
v
v
v
Introduccin
El problema de las ocho reinas
El problema de la suma de
subconjuntos
Coloreado de grafos
Ciclos hamiltonianos
Atravesar un laberinto
El recorrido del caballo de ajedrez
El problema de la mochila 0-1
Reconstruccin de puntos
a partir de las distancias
rboles de juego: tic-tac-toe
J. Campos - C.P.S.
2
16
26
36
44
52
56
74
85
95
Esquemas algortmicos - Bsqueda con retroceso
Bsqueda con retroceso:

Introduccin
v
Problemas que consideraremos:

Bsqueda de la mejor o del conjunto de todas
las soluciones que satisfacen ciertas
condiciones.
Cada solucin es el resultado de una secuencia
de decisiones.
Existe una funcin objetivo que debe ser
satisfecha por cada seleccin u optimizada (si
slo queremos la mejor).
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.
J. Campos - C.P.S.

Introduccin
v
Planteamiento del problema:

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

Mtodo de fuerza bruta: examinar las t n-tuplas
y seleccionar las que satisfacen P.
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.
J. Campos - C.P.S.

Introduccin
Deben existir unas funciones objetivo parciales o
predicados acotadores Pi(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:
u explcitas: describen el conjunto Ci de
valores que puede tomar xi (todas las tuplas
que satisfacen estas restricciones definen un
espacio de soluciones posibles);
u implcitas: describen las relaciones que
deben cumplirse entre los xi (qu soluciones
posibles satisfacen el predicado objetivo P).
J. Campos - C.P.S.

Introduccin
v
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).
64
Fuerza bruta: = 4.426.165.368
8
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.
J. Campos - C.P.S.

Introduccin
Restricciones explcitas:
Ci = {1,2,3,4,5,6,7,8}, 1=i=8
El espacio de soluciones consta de
88 8-tuplas (16.777.216 8-tuplas)
Restricciones implcitas:
no puede haber dos reinas en la misma
columna ni en la misma diagonal
En particular, se deduce que todas las soluciones
son permutaciones de la 8-tupla (1,2,3,4,5,6,7,8).
El espacio de soluciones se reduce de
88 8-tuplas (16.777.216) a 8! 8-tuplas (40.320)
1 2
3 4
6 7 8
1
2
3
4
5
6
7
8
Una solucin: (4,6,8,2,7,1,3,5)
J. Campos - C.P.S.

Introduccin
v
Volviendo al planteamiento general:

Para facilitar la bsqueda, se adopta una
organizacin en rbol del espacio de soluciones.
En el ejemplo, para el problema de las

cuatro reinas (en un tablero 44):
1
x1 =1
x1 =2
18
x2 =2
x2 =3
3
x3 =
x4 =
3
5
x2 =4
x2 =1
x2 =3
13
4 2
x1 =4
x1 =3
4 2
19
11 14 16
10 12 15 17
24
29
4 1
35
20 22 25 27 30 32
4
2
x2 =1
x2 =2
x2 =4
4 1
34
21 23 26 28 31 33
40
45
4 1
51
36 38 41 43 46 48
4
1
x2 =1
x2 =2
x2 =4
4 1
50
37 39 42 44 47 49
56
3 1
61
3 1
53 55 58 60 63 65
El espacio de soluciones est definido por todos los

caminos desde la raz a cada hoja (hay 4! hojas).
J. Campos - C.P.S.
52 54 57 59 62 64
3
2
x2 =3

Introduccin
v
Esquema algortmico:
Sea (x1,,xi) un camino de la raz hasta un nodo
del rbol del espacio de estados.
Sea G(x1,,xi) el conjunto de los valores posibles
de xi+1 tales que (x1,,xi+1) es un camino hasta un
nodo del rbol.
Suponemos que existe algn predicado acotador
A tal que A(x1,,xi+1) es falso si el camino
(x1,,xi+1) no puede extenderse para alcanzar un
nodo de respuesta (i.e., una solucin).
Por tanto, los candidatos para xi+1 son los valores
de G tales que satisfacen A.
Supongamos, finalmente, que existe un
predicado R que determina si un camino
(x1,,xi+1) termina en un nodo respuesta (i.e., es
ya una solucin).
J. Campos - C.P.S.

Introduccin
algoritmo
algoritmo retroceso(ent
retroceso(ent k:entero;
k:entero;
entsal
entsal solucin:vector[1..n]de
solucin:vector[1..n]de elmto)
elmto)
{Pre:
{Pre: solucin[1..k-1]
solucin[1..k-1] es
es prometedora}
prometedora}
variable
variable nodo:elmto
nodo:elmto
principio
principio
para
para todo
todo nodo
nodo en
en G(solucin,1,k-1)
G(solucin,1,k-1) hacer
hacer
solucin[k]:=nodo;
solucin[k]:=nodo;
si
si A(solucin,1,k)
A(solucin,1,k)
entonces
entonces
si
si R(solucin,1,k)
R(solucin,1,k)
entonces
entonces guardar(solucin,1,k)
guardar(solucin,1,k)
fsi;
fsi;
retroceso(k+1,solucin)
retroceso(k+1,solucin)
fsi
fsi
fpara
fpara
fin
fin
La llamada inicial es:

...
...
retroceso(1,solucin);
retroceso(1,solucin);
...
...
J. Campos - C.P.S.

Introduccin
v
En el ejemplo de las cuatro reinas:

(a)
(b)
(c)
(d)
x1 =1

(e)

(f)
18
x2 =2
x2 =3
3
x3 =
(g)
x1 =2
2
9
x4 =
x2 =4
13
4 2
x2 =1
x2 =3
19
24
11 14 16
3
15
29
1
30
3
31
(16 nodos frente a

los 65 del rbol completo)
(h)
J. Campos - C.P.S.
x2 =4

Introduccin
v
De nuevo, en general:
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:
u k = n+1, o cuando
u ningn nodo generado por G satisface A.
Backtracking =
= bsqueda de primero en profundidad y
con predicados acotadores
J. Campos - C.P.S.

Introduccin
El algoritmo anterior halla todas las soluciones y
adems stas pueden ser de longitud variable.
v
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):
si R(solucin,1,k)
entonces guardar(solucin,1,k)
sino retroceso(k+1,solucin)
fsi
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 los
predicados acotadores 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).
J. Campos - C.P.S.

Introduccin
v
Sobre la eficiencia:
Depende de:
u el tiempo necesario para generar un
elemento solucin[k],
u el nmero de elementos solucin que
satisfacen las restricciones explcitas G,
u el tiempo de ejecucin de los predicados
acotadores A, y
u el nmero de elementos solucin[k] que
satisfacen los predicados A.
Mejoras:
u 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(n) nodos a generar
en total
En el peor caso, O(p(n)2n) O(p(n)n!),
con p(n) un polinomio
u Si es posible: reordenar las selecciones de
forma que |C1|<|C2|<<|Cn|, y as cabe
esperar que se explorarn menos caminos.
J. Campos - C.P.S.

Introduccin
Estimacin a priori del nmero de nodos
generados:
u Idea: generar un camino aleatorio en el
rbol del espacio de estados.
u Sea xi el nodo del camino aleatorio en el
nivel i y sea mi el nmero de hijos de xi que
satisfacen el predicado acotador A.
u El siguiente nodo del camino aleatorio se
obtiene aleatoriamente de entre esos mi.
u La generacin termina en un nodo de
respuesta (solucin) o en un nodo por el que
no se puede seguir (ninguno de sus hijos
satisfacen el predicado acotador).
u Si los predicados acotadores son estticos
(no cambian en toda la bsqueda; esto no es
lo habitual; lo habitual es que se hagan cada
vez ms restrictivos) y ms an si los nodos
de un mismo nivel tienen todos igual grado,
entonces:
El nmero estimado de nodos que se
generar con el algoritmo de bsqueda con
retroceso es:
m = 1 + m 1 + m 1 m 2 + m 1m 2m 3 +L
J. Campos - C.P.S.

Introduccin
funcin
funcin estimacin
estimacin devuelve
devuelve entero
entero
variables
variables k,m,r,card:entero;
k,m,r,card:entero;
nodo:elmto;
nodo:elmto;
sol:vector[1..n]de
sol:vector[1..n]de elmto
elmto
principio
principio
k:=1;
k:=1; m:=0;
m:=0; r:=1;
r:=1;
repetir
repetir
card:=0;
card:=0;
para
para todo
todo nodo
nodo en
en G(sol,1,k-1)
G(sol,1,k-1) hacer
hacer
sol[k]:=nodo;
sol[k]:=nodo;
si
si A(sol,1,k)
A(sol,1,k)
entonces
entonces card:=card+1
card:=card+1
fsi
fsi
fpara;
fpara;
si
si card
card00
entonces
entonces
r:=r*card;
r:=r*card;
m:=m+r;
m:=m+r;
sol[k]:=eleccAleat(G(sol,1,k-1));
sol[k]:=eleccAleat(G(sol,1,k-1));
k:=k+1
k:=k+1
fsi
fsi
hastaQue
hastaQue R(sol,1,k)
R(sol,1,k) or
or (card=0);
(card=0);
devuelve
devuelve mm
fin
fin
J. Campos - C.P.S.

v
Consideraremos el problema ms
general de colocar n reinas en un
tablero de dimensiones nn, sin que se
den jaque.
Cada solucin se representa por una n-tupla
(x1,,xn), 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.
Adems, no deben compartir diagonal.
J. Campos - C.P.S.

v
Representacin de la informacin
Debe permitir interpretar fcilmente la solucin:
x:vector[1..n]de entero;
{x[i]=columna de la reina en i-sima fila}
Evaluacin del predicado acotador:

Utilizaremos una funcin 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 estn en la misma diagonal si
tienen el mismo valor de fila+columna,
mientras que estn 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 )
J. Campos - C.P.S.
c1 c2 = f 1 f 2

funcion
funcion buenSitio(k:entero;
buenSitio(k:entero;
x:vector[1..n]de
x:vector[1..n]de entero)
entero)
devuelve
devuelve bool
bool
{devuelve
{devuelve verdad
verdad si
si yy slo
slo si
si se
se puede
puede colocar
colocar
una
reina
en
la
fila
k
y
columna
x[k],
una reina en la fila k y columna x[k], habiendo
habiendo
sido
colocadas
ya
las
k-1
reinas
anteriores}
sido colocadas ya las k-1 reinas anteriores}
variables
variables i:entero;
i:entero; amenaza:bool
amenaza:bool
principio
principio
i:=1;
i:=1; amenaza:=falso;
amenaza:=falso;
mq
(i<k)
mq (i<k) and
and not
not amenaza
amenaza hacer
hacer
si
si x[i]=x[k]
x[i]=x[k] or
or abs(x[i]-x[k])=abs(i-k)
abs(x[i]-x[k])=abs(i-k)
entonces
entonces amenaza:=verdad
amenaza:=verdad
sino
sino i:=i+1
i:=i+1
fsi
fsi
fmq;
fmq;
devuelve
devuelve not
not amenaza
amenaza
fin
fin
El coste de la funcin es O(k-1).
J. Campos - C.P.S.

Versin recursiva:
algoritmo
algoritmo colocarReinas(ent
colocarReinas(ent k:entero;
k:entero;
entsal
sol:vector[1..n]de
entsal sol:vector[1..n]de entero)
entero)
{sol[1..k-1]
{sol[1..k-1] estn
estn bien
bien colocadas}
colocadas}
variables
variables i:entero
i:entero
principio
principio
para
para i:=1
i:=1 hasta
hasta nn hacer
hacer
sol[k]:=i;
sol[k]:=i;
si
si buenSitio(k,sol)
buenSitio(k,sol)
entonces
entonces
si
si k=n
k=n
entonces
entonces escribir(sol)
escribir(sol)
sino
sino colocarReinas(k+1,sol)
colocarReinas(k+1,sol)
fsi
fsi
fsi
fsi
fpara
fpara
fin
fin
...
...
colocarReinas(1,sol);
colocarReinas(1,sol);
...
...
J. Campos - C.P.S.

Versin iterativa:
algoritmo
algoritmo nReinas(ent
nReinas(ent n:entero)
n:entero)
variables
variables k:entero;
k:entero; x:vector[1..n]de
x:vector[1..n]de entero
entero
principio
principio
x[1]:=0;
x[1]:=0; k:=1;
k:=1;
mq
k>0
hacer
mq k>0 hacer {para
{para frenar
frenar el
el ltimo
ltimo retroceso}
retroceso}
x[k]:=x[k]+1;
x[k]:=x[k]+1;
mq
mq x[k]
x[k]nn and
and not
not buenSitio(k,x)
buenSitio(k,x) hacer
hacer
x[k]:=x[k]+1
x[k]:=x[k]+1
fmq;
fmq;
si
si x[k]
x[k]nn {se
{se ha
ha encontrado
encontrado un
un buen
buen sitio}
sitio}
entonces
entonces
si
si k=n
k=n {es
{es una
una solucin
solucin completa?}
completa?}
entonces
entonces
escribir(x)
escribir(x) {si:
{si: escribirla}
escribirla}
sino
sino
k:=k+1;
k:=k+1;
x[k]:=0
x[k]:=0 {ir
{ir aa la
la siguiente
siguiente fila}
fila}
fsi
fsi
sino
sino
k:=k-1
k:=k-1 {retroceso}
{retroceso}
fsi
fsi
fmq
fmq
fin
fin
J. Campos - C.P.S.

v
Estimacin del coste:

Se realizaron cinco evaluaciones de la funcin
estimacin, con los siguientes resultados:
(8,5,4,3,2)1649
(8,5,3,1,2,1)749
(8,6,4,3,2)1977
(8,6,4,2,1,1,1)1401
(8,5,3,2,2,1,1,1)2329
Con cada eleccin se guarda el nmero de

columnas en que es posible colocar la reina y a
partir de l se calcula el valor que devuelve la
funcin. Recordar: m = 1 + m 1 + m 1 m 2 + m 1m 2m 3 +L
J. Campos - C.P.S.

La media para las cinco evaluaciones es 1625.
El nmero total de nodos del espacio de estados
es:
j
1+
(8 i) = 69281
j = 0 i = 0
Por tanto, nicamente se recorrera un 234% del

nmero total de nodos (si la estimacin es
acertada).
En este caso, la estimacin es algo optimista pues

se puede comprobar que el nmero de nodos
explorados es 2057 y, por tanto, se recorre un 297%.
Nmero de soluciones para n=8: 92.

Mejora adicional: observar que algunas
soluciones son simplemente rotaciones o
reflexiones de otras.
Para encontrar soluciones no equivalentes, el

algoritmo slo debe probar con x[1]= 2, 3, , n 2
J. Campos - C.P.S.

v
Para n mayor:
la mejora se hace ms considerable.
Por ejemplo, n=12:

nmero de permutaciones: 12! = 479.001.600
nmero total de nodos
del espacio de estados:
1.302.061.345
nmero de nodos explorados: 856.189

se recorre slo un 0065%
(se obtiene la primera solucin tras visitar
262 nodos)
J. Campos - C.P.S.

v
Novedad:
Recientemente se ha encontrado una
solucin compacta para el problema
general de las n reinas en un tablero
nn (excepto para n=2, n=3, n=8 y n=9):
Si n es impar (n=2p-1) y n3 y n9:
u Si n no es mltiplo de 3:
(2k-1,k), 1kp
(2m,m+p), 1mp-1
u Si n es mltiplo de 3 y n3 y n9:
(2k,k), 1kp-1, k4
(2m+1,m+p-1), 1mp-2
(n,4)
(8,n-1)
(1,n)
J. Campos - C.P.S.

Si n es par (n=2p) y n2 y n8:
u Si not(n2 md 3):
(2k,k), 1kp
(2m-1,m+p), 1mp
u Si n2 md 3 y n2 y n8:
(2k-1,k), 1kp, k4
(2m,m+p), 1mp-1
(n,4)
(7,n)
J. Campos - C.P.S.
subconjuntos
v
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), 1kn.
J. Campos - C.P.S.
subconjuntos
v
Restricciones sobre las soluciones

(para la primera representacin):
Explcitas:
xi j
j es un entero y
1 j n
Implcitas:
i j xi x j
k
w xi = M
i= 1
xi < xi +1 , 1 i < n
J. Campos - C.P.S.
(para evitar generar varias

instancias de la misma tupla)
subconjuntos
v
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:
u xi = 0 si wi no se elige y
u 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.
J. Campos - C.P.S.
subconjuntos
v
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 x i.
El espacio de soluciones est definido por todos
los caminos desde la raz hasta cualquier nodo
del rbol.
1
x1 =1
x1 =2
3
x2 =2
x2 =3 x =4
2
6
x3 =3
x3 =4 x3 =4
12 13
14
x1 =4
x1 =3
x2 =3 x2 =4
8
10
x2 =4
11
x3 =4
15
x4 =4
16
Los nodos se han numerado segn un recorrido

en anchura (utilizando para ello una cola).
J. Campos - C.P.S.
subconjuntos
v
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 las 16 posibles 4-tuplas).
1
x1 =1
x1 =0
x2 =1
x2 =0
18
x2 =1
19
x3 =1
x3 =0
26
x3 =1
27
x3 =0
20
31
28
29
24
21
25
22
x3 =1
x3 =0
12
x4 =0
x4 =0
x4 =0
x4 =0
x4 =1
x4 =1
x4 =1
x4 =1
x4 =1
30
x2 =0
23
16
x3 =1
13
x4 =0
x4 =1
17
14
x3 =0
x4 =0
x4 =1
15
10
x4 =0
x4 =1
11
x4 =0
Los nodos estn numerados de acuerdo con un

recorrido de D-bsqueda (consiste en explorar
primero el ltimo de los nodos aadido a la lista
de nodos por explorar, es decir, utilizando una
pila).
J. Campos - C.P.S.
subconjuntos
v
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.
Generacin de los hijos de un nodo:
u para un nodo del nivel i el hijo izquierdo
corresponde a x[i]=1 y el derecho a x[i]=0.
J. Campos - C.P.S.
subconjuntos
Funcin acotadora:
La tupla (x[1],x[k]) slo puede conducir a una
solucin si:
k
w[i ] x[ i ]
i =1
w [i ] M
i =k +1
Si adems se sabe que los w[i] estn ordenados

de forma no-decreciente, la tupla (x[1],x[k]) no
puede conducir a una solucin si:
k
w[i ] x[ i ]
+ w [k + 1] > M
i =1
Es decir, una funcin acotadora es:
Bk x[1],,x[k ] = verdad si y slo si

n
k
w [i ] x[ i ] + w [ i ] M
i =1
i =k +1
k
w [ i ] x[ i ] + w [ k + 1] M
i =1
J. Campos - C.P.S.
subconjuntos
algoritmo
algoritmo sumasub(ent
sumasub(ent s,k,r:entero)
s,k,r:entero)
{Encuentra
{Encuentra todos
todos los
los subconjuntos
subconjuntos del
del vector
vector
global
global ww cuya
cuya suma
suma es
es M.
M.
Los
valores
de
x[j],
que
Los valores de x[j], que es
es otro
otro vector
vector global,
global,
1j<k
ya
han
sido
calculados.
1j<k ya han sido calculados.
k -1
s=
s= j=1 w[j]*x[j];
w[j]*x[j]; r=
r= j=k w[j].
w[j].
Los
Los w[j]
w[j] estn
estn en
en orden
ordennno
no decreciente.
decreciente.
Se
asume
que
w[1]M
y
w[i]M.}
Se asume que w[1]M y i=1 w[i]M.}
principio
principio
{Generacin
{Generacin del
del hijo
hijo izquierdo.
izquierdo.
Ntese
que
s+w[k]M
porque
Ntese que s+w[k]M porqueBk 1 (x[ 1] ,,x[k - 1]) =verdad }}
x[k]:=1;
x[k]:=1;
si
si s+w[k]=M
s+w[k]=M {se
{se ha
ha encontrado
encontrado un
un subconjunto}
subconjunto}
entonces
entonces escribir(x[1..k])
escribir(x[1..k])
sino
sino
si
si s+w[k]+w[k+1]
s+w[k]+w[k+1]MM
entonces
entonces {Bk (x[ 1] ,,x [k ]) =verdad}
sumasub(s+w[k],k+1,r-w[k])
sumasub(s+w[k],k+1,r-w[k])
fsi
fsi
fsi
fsi
...
...
J. Campos - C.P.S.
subconjuntos
...
...
{Generacin
{Generacin del
del hijo
hijo derecho
derecho yy evaluacin
evaluacin de
deBk }}
si
si (s+r-w[k]
(s+r-w[k]M)
M) and
and (s+w[k+1]
(s+w[k+1]M)
M) {Bk =verdad}
entonces
entonces
x[k]:=0;
x[k]:=0;
sumasub(s,k+1,r-w[k])
sumasub(s,k+1,r-w[k])
fsi
fsi
fin
fin
Ntese que el algoritmo evita calcular
i =1 w[ i ]x[i ]
k
i =k +1 w[i ]
cada vez guardando esos valores en s y r.

...
...
n
sumasub(0,1,
sumasub(0,1, i=1w[i])
w[i])
...
...
J. Campos - C.P.S.
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 23 nodos (del total de 26-1=63)
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
27,4,46
x[3]=0
15,4,46
x[3]=1
17,4,46
x[4]=1
x[4]=0
15,5,33
x[5]=1
10,3,58
0,3,58
x[3]=0
0,4,46
10,4,46
12,4,46
10,5,33
12,5,33
13,5,33
12,6,18
13,6,18
5,4,46
x[4]=0
5,5,33
x[5]=1
20,6,18
J. Campos - C.P.S.
0,5,33
Coloreado de grafos
v
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?
J. Campos - C.P.S.
Coloreado de grafos
v
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?
4
5
2
1
5
3
4
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.
J. Campos - C.P.S.
Coloreado de grafos
v
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.
tipo
tipo grafo
grafo == vector[1..n,1..n]
vector[1..n,1..n] de
de bool
bool
Justificacin de la eleccin: slo necesitaremos
saber si un arco existe o no.
Representacin de los colores: enteros de 1 a m.
tipo
tipo color
color == 0..m
0..m
Representacin de la solucin: vector de colores.
tipo
tipo sol
sol == vector[1..n]
vector[1..n] de
de color
color
J. Campos - C.P.S.
Coloreado de grafos
v
Espacio de estados para n=3 y m=3.

x[1]=1
x[2]=1
x[3]=1
x[2]=2
x[1]=2
x[1]=3
x[2]=3
x[3]=
3
x[3]
=2
Grado m y altura n.
Cada nodo de nivel i tiene m hijos que
corresponden a las m posibles asignaciones a x[i],
1in.
J. Campos - C.P.S.
Coloreado de grafos
v
Solucin de bsqueda con retroceso:
algoritmo
algoritmo m_coloreado(ent
m_coloreado(ent k:entero;
k:entero;
entsal
entsal x:sol)
x:sol)
{Se
{Se usa
usa una
una variable
variable global
global gg de
de tipo
tipo grafo.
grafo.
En
En xx se
se tiene
tiene la
la parte
parte de
de la
la solucin
solucin ya
ya calculada
calculada
(es
(es decir,
decir, hasta
hasta x[k-1])
x[k-1]) yy kk es
es el
el ndice
ndice del
del
siguiente
vrtice
al
que
se
va
a
asignar
color.}
siguiente vrtice al que se va a asignar color.}
principio
principio
repetir
repetir
{generar
{generar todos
todos los
los colores
colores legales
legales para
para x[k]}
x[k]}
siguienteValor(x,k);
{x[k]:=un
color
legal}
siguienteValor(x,k); {x[k]:=un color legal}
si
si x[k]
x[k]00 {se
{se ha
ha encontrado
encontrado un
un color
color legal}
legal}
entonces
entonces
si
si k=n
k=n
entonces
entonces escribir(x)
escribir(x)
sino
sino m_coloreado(k+1,x)
m_coloreado(k+1,x)
fsi
fsi
fsi
fsi
hastaQue
hastaQue x[k]=0
x[k]=0
fin
fin
J. Campos - C.P.S.
Coloreado de grafos
algoritmo
algoritmo siguienteValor(entsal
siguienteValor(entsal x:sol;
x:sol;
ent
ent k:entero)
k:entero)
{x[1]x[k-1]
{x[1]x[k-1] tienen
tienen colores
colores asociados
asociados de
de forma
forma
que
todos
los
vrtice
adyacentes
tienen
distinto
que todos los vrtice adyacentes tienen distinto
color.
color.
x[k]
x[k] tiene
tiene el
el anterior
anterior color
color para
para el
el que
que se
se ha
ha
probado
(0
si
no
se
ha
probado
con
ninguno).
probado (0 si no se ha probado con ninguno).
Se
Se calcula
calcula el
el siguiente
siguiente color
color para
para x[k]
x[k]
diferente
del
de
todos
los
vrtices
diferente del de todos los vrtices adyacentes
adyacentes
aa kk (0
(0 si
si no
no hay
hay ninguno).}
ninguno).}
variables
variables encontrado:booleano;
encontrado:booleano; j:entero
j:entero
principio
principio
repetir
repetir
x[k]:=(x[k]+1)
x[k]:=(x[k]+1) mod
mod (m+1);
(m+1); {siguiente
{siguiente color}
color}
si
si x[k]
x[k]00
entonces
entonces
encontrado:=verdad;
encontrado:=verdad;
j:=1;
j:=1;
mq
mq (jn)
(jn) and
and encontrado
encontrado hacer
hacer
si
g[k,j]
and
(x[k]=x[j])
si g[k,j] and (x[k]=x[j])
entonces
entonces encontrado:=falso
encontrado:=falso
sino
sino j:=j+1
j:=j+1
fsi
fsi
fmq
fmq
fsi
fsi
hastaQue
hastaQue (x[k]=0)
(x[k]=0) or
or encontrado
encontrado
fin
fin
J. Campos - C.P.S.
Coloreado de grafos
v

...
...
{g
{g contiene
contiene la
la matriz
matriz de
de adyacencia
adyacencia del
del grafo}
grafo}
para
para i:=1
i:=1 hasta
hasta nn hacer
hacer
x[i]:=0
x[i]:=0
fpara;
fpara;
m_coloreado(1,x);
m_coloreado(1,x);
...
...
J. Campos - C.P.S.
Coloreado de grafos
v
Cota superior del coste temporal:

Nmero de nodos internos del rbol del espacio
de estados:
n 1
mi
i =0
Coste de siguienteValor para cada nodo

interno:
O (mn)
Cota del tiempo total:
mi n = n (m n + 1 1 ) (m 1)= O (nm n )
n
i= 1
Recordar que ya vimos una heurstica

voraz muy eficiente
J. Campos - C.P.S.
v
Problema: encontrar todos los ciclos

hamiltonianos de un grafo.
Sea G=(V,A) un grafo 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:
u
viV, i=1,,n+1,
(vi,vi+1)A, i=1,,n,
v1=vn+1,
vivj, i,j=1,,n tales que ij.
J. Campos - C.P.S.
v
Ejemplos:
1
Hamiltoniano: 1-2-8-7-6-5-4-3-1
1
5
No contiene ningn hamiltoniano.
J. Campos - C.P.S.
v
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
(para el caso de un grafo con todas las
distancias entre vrtices iguales)
Recordar que ya vimos una heurstica voraz muy
eficiente pero subptima para el problema del
viajante de comercio.
Recordar que vimos tambin la solucin de
programacin dinmica y comparamos su
eficiencia con la solucin de fuerza bruta.
J. Campos - C.P.S.
v
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 x k si x1,,xk-1
ya tienen valores asignados:
u
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.
J. Campos - C.P.S.
Representacin elegida: matriz de adyacencias.
tipo
tipo grafo
grafo == vector[1..n,1..n]
de bool
bool
Justificacin de la eleccin: slo necesitaremos
saber si un arco existe o no.
Representacin de la solucin: vector de vrtices.
tipo
tipo sol
sol == vector[1..n]
vector[1..n] de
de 1..n
1..n
algoritmo
algoritmo siguienteValor(entsal
siguienteValor(entsal x:sol;
x:sol;
ent
ent k:entero)
k:entero)
{x[1],,x[k-1]
{x[1],,x[k-1] es
es un
un camino
camino de
de k-1
k-1 vrtices
vrtices
distintos.
distintos.
Si
Si x[k]=0,
x[k]=0, no
no se
se ha
ha asignado
asignado ningn
ningn vrtice
vrtice
todava
todava aa x[k].
x[k].
Al
terminar,
Al terminar, x[k]
x[k] toma
toma el
el valor
valor del
del siguiente
siguiente
(en
orden
ascendente)
vrtice
tal
que:
(en orden ascendente) vrtice tal que:
(1)
(1) no
no aparece
aparece ya
ya en
en x[1],,x[k-1],
x[1],,x[k-1], yy
(2)
(2) est
est conectado
conectado por
por un
un arco
arco aa x[k-1].
x[k-1].
Adems,
Adems, si
si k=n,
k=n, se
se debe
debe exigir
exigir aa x[k]
x[k] que:
que:
(3)
(3) est
est conectado
conectado por
por un
un arco
arco aa x[1].
x[1].
Si
no
hay
tal
vrtice,
x[k]=0.}
Si no hay tal vrtice, x[k]=0.}
...
...
J. Campos - C.P.S.
...
...
variables
variables encontrado:booleano;
encontrado:booleano; j:entero
j:entero
principio
principio
repetir
repetir
x[k]:=(x[k]+1)
x[k]:=(x[k]+1) mod
mod (n+1);
(n+1);
si
si x[k]
x[k]00
entonces
entonces
encontrado:=falso;
encontrado:=falso;
si
si g[x[k-1],x[k]]
g[x[k-1],x[k]]
entonces
entonces
j:=1;
j:=1;
encontrado:=verdad;
encontrado:=verdad;
mq
mq (jk-1)
(jk-1) and
and encontrado
encontrado hacer
hacer
si
x[j]=x[k]
si x[j]=x[k]
entonces
encontrado:=falso
sino
sino j:=j+1
j:=j+1
fsi
fsi
fmq;
fmq;
si
si encontrado
encontrado entonces
entonces
si
si (k=n)
(k=n) and
and not
not g[x[n],1]
g[x[n],1]
entonces
encontrado:=falso
fsi
fsi
fsi
fsi
fsi
fsi
fsi
fsi
hastaQue
hastaQue (x[k]=0)
(x[k]=0) or
or encontrado
encontrado
fin
fin
J. Campos - C.P.S.
algoritmo
algoritmo hamiltoniano(ent
hamiltoniano(ent k:entero;
k:entero;
entsal
entsal x:sol)
x:sol)
{Se
{Se usa
usa una
una variable
variable global
global gg de
de tipo
tipo grafo.
grafo.
Clculo
de
los
ciclos
hamiltonianos
de
Clculo de los ciclos hamiltonianos de un
un grafo
grafo
mediante
bsqueda
con
retroceso.
mediante bsqueda con retroceso.
En
En xx se
se tiene
tiene la
la parte
parte de
de la
la solucin
solucin ya
ya calculada
calculada
(es
(es decir,
decir, hasta
hasta x[k-1])
x[k-1]) yy kk es
es el
el ndice
ndice del
del
siguiente
siguiente vrtice
vrtice del
del ciclo
ciclo que
que se
se va
va aa asignar.}
asignar.}
principio
principio
repetir
repetir
{generar
{generar todos
todos los
los valores
valores legales
legales para
para x[k]}
x[k]}
si
si x[k]
x[k]00
entonces
entonces
si
si k=n
k=n
entonces
entonces
escribir(x,1)
escribir(x,1)
sino
sino hamiltoniano(k+1,x)
hamiltoniano(k+1,x)
fsi
fsi
fsi
fsi
hastaQue
hastaQue x[k]=0
x[k]=0
fin
fin
J. Campos - C.P.S.
v

...
...
{g
{g contiene
contiene la
la matriz
matriz de
de adyacencia
adyacencia del
del grafo}
grafo}
x[1]:=1;
x[1]:=1;
para
para i:=2
i:=2 hasta
hasta nn hacer
hacer
x[i]:=0
x[i]:=0
fpara;
fpara;
hamiltoniano(2,x);
hamiltoniano(2,x);
...
...
J. Campos - C.P.S.
v
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).
J. Campos - C.P.S.
Disearemos un algoritmo
de bsqueda con retroceso
de forma que se marcar
en la misma matriz del
laberinto un camino
solucin (si existe).
Si por un camino recorrido

se llega a una casilla desde
la que es imposible
encontrar una solucin,
hay que volver atrs y
buscar otro camino.
XXX
X
XX
XXX
XX
XXX X
X XXXX
XX
XXX
XXX
X
XX
X
XXXXX
XXX 5 5
X 555
X 55
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
J. Campos - C.P.S.
v
Estructura de datos:
tipos
tipos
casilla
casilla == (libre,pared,camino,imposible)
(libre,pared,camino,imposible)
laberinto
=
laberinto = vector[1..n,1..n]
de casilla
casilla
v Solucin de bsqueda con retroceso:

algoritmo
algoritmo buscarCamino(entsal
buscarCamino(entsal lab:laberinto;
lab:laberinto;
sal
sal xito:booleano)
xito:booleano)
principio
principio
ensayar(1,1,lab,xito)
ensayar(1,1,lab,xito)
fin
fin
algoritmo
algoritmo ensayar(ent
ensayar(ent x,y:entero;
x,y:entero;
entsal
entsal lab:laberinto;
lab:laberinto;
sal
sal encontrado:booleano)
encontrado:booleano)
principio
principio
si
si (x<1)
(x<1)(x>n)
(x>n)(y<1)
(y<1)(y>n)
(y>n)
entonces
entonces {posicin
{posicin fuera
fuera del
del laberinto}
laberinto}
encontrado:=falso
encontrado:=falso
sino
sino
si
si lab[x,y]
lab[x,y]libre
libre
entonces
encontrado:=falso
sino
sino
...
...
J. Campos - C.P.S.
...
...
lab[x,y]:=camino;
lab[x,y]:=camino;
si
si (x=n)
(x=n)(y=n)
(y=n)
entonces
entonces {se
{se ha
ha encontrado
encontrado una
una soluc.}
soluc.}
encontrado:=verdad
encontrado:=verdad
sino
sino
ensayar(x+1,y,lab,encontrado);
ensayar(x+1,y,lab,encontrado);
si
si not
not encontrado
encontrado
entonces
entonces
ensayar(x,y+1,lab,encontrado)
ensayar(x,y+1,lab,encontrado)
fsi;
fsi;
si
si not
not encontrado
encontrado
entonces
entonces
ensayar(x-1,y,lab,encontrado)
ensayar(x-1,y,lab,encontrado)
fsi;
fsi;
si
si not
not encontrado
encontrado
entonces
entonces
ensayar(x,y-1,lab,encontrado)
ensayar(x,y-1,lab,encontrado)
fsi;
fsi;
si
si not
not encontrado
encontrado
entonces
entonces
lab[x,y]:=imposible
lab[x,y]:=imposible
fsi
fsi
fsi
fsi
fsi
fsi
fsi
fsi
fin
fin
J. Campos - C.P.S.
El recorrido del caballo de

ajedrez
v
Problema:
Se trata de encontrar una sucesin de
movimientos legales de un caballo de ajedrez
de forma que ste pueda visitar todos y cada uno
de los escaques (cuadros) de un tablero sin
repetir ninguno.
1 2 3 4 5 6 7 8
1
2
3
4
5
6
7
8
J. Campos - C.P.S.

ajedrez
Movimientos legales:
6
1
3
variables
variables dx,dy:vector[1..8]
dx,dy:vector[1..8] de
de entero
entero
...
...
dx:=[2,1,-1,-2,-2,-1,1,2]
dx:=[2,1,-1,-2,-2,-1,1,2]
dy:=[1,2,2,1,-1,-2,-2,-1]
dy:=[1,2,2,1,-1,-2,-2,-1]
Estructura de datos: matriz de naturales
u inicialmente: todos cero
u al terminar: cada componente guarda el
nmero de orden en que se visit el escaque
correspondiente
variable
variable
tab:vector[1..n,1..n]
tab:vector[1..n,1..n] de
de entero
entero
J. Campos - C.P.S.

ajedrez
algoritmo
algoritmo ensaya(ent
ensaya(ent i,x,y:entero;
i,x,y:entero;
sal
xito:booleano)
sal xito:booleano)
{Ensaya
{Ensaya el
el movimiento
movimiento al
al i-simo
i-simo escaque
escaque desde
desde
el
x,y.
Si
el
movimiento
es
posible
y
tras
el x,y. Si el movimiento es posible y tras l
l se
se
puede
seguir
moviendo
hasta
encontrar
la
solucin
puede seguir moviendo hasta encontrar la solucin
entonces
entonces xito
xito devuelve
devuelve verdad,
verdad, si
si no
no falso.}
falso.}
variables
variables k,u,v:entero
k,u,v:entero
principio
principio
k:=0;
k:=0;
repetir
repetir {se
{se ensaya
ensaya con
con los
los 88 mov.
mov. posibles}
posibles}
k:=k+1;
k:=k+1; xito:=falso;
xito:=falso;
u:=x+dx[k];
u:=x+dx[k]; v:=y+dy[k];
v:=y+dy[k];
si
si (1
(1u)
u)(u
(un)
n)(1
(1v)
v)(v
(vn)
n) entonces
entonces
si
si tab[u,v]=0
tab[u,v]=0 entonces
entonces
tab[u,v]:=i;
tab[u,v]:=i;
si
si i<n*n
i<n*n
entonces
entonces
ensaya(i+1,u,v,xito);
si
si not
not xito
xito
entonces
entonces tab[u,v]:=0
tab[u,v]:=0
fsi
fsi
sino
sino xito:=verdad
xito:=verdad
fsi
fsi
fsi
fsi
fsi
fsi
hastaQue
hastaQue xito
xito or
or (k=8)
(k=8)
fin
fin
J. Campos - C.P.S.

ajedrez
algoritmo
algoritmo caballo
caballo
constante
constante n=8
n=8
variables
de entero;
entero;
de entero;
entero;
i,j:entero;
i,j:entero; xito:booleano
xito:booleano
principio
principio
dx[1]:=2;
dx[1]:=2; dx[2]:=1;
dx[2]:=1; dx[3]:=-1;
dx[3]:=-1; dx[4]:=-2;
dx[4]:=-2;
dx[5]:=-2;
dx[5]:=-2; dx[6]:=-1;
dx[6]:=-1; dx[7]:=1;
dx[7]:=1; dx[8]:=2;
dx[8]:=2;
dy[1]:=1;
dy[1]:=1; dy[2]:=2;
dy[2]:=2; dy[3]:=2;
dy[3]:=2; dy[4]:=1;
dy[4]:=1;
dy[5]:=-1;
dy[5]:=-1; dy[6]:=-2;
dy[6]:=-2; dy[7]:=-2;
dy[7]:=-2; dy[8]:=-1;
dy[8]:=-1;
para
para i:=1
i:=1 hasta
hasta nn hacer
hacer
para
para j:=1
j:=1 hasta
hasta nn hacer
hacer
tab[i,j]:=0
tab[i,j]:=0
fpara;
fpara;
fpara;
fpara;
escribir(Introduce
escribir(Introduce ii inicial:);
inicial:); leer(i);
leer(i);
escribir(Introduce
escribir(Introduce jj inicial:);
inicial:); leer(j);
leer(j);
tab[i,j]:=1;
tab[i,j]:=1;
ensaya(2,i,j,xito);
ensaya(2,i,j,xito);
...
...
J. Campos - C.P.S.

ajedrez
...
...
si
si xito
xito
entonces
entonces
para
para i:=1
i:=1 hasta
hasta nn hacer
hacer
para
para j:=1
j:=1 hasta
hasta nn hacer
hacer
escribir(tab[i,j]);
escribir(tab[i,j]);
fpara;
fpara;
escribirLnea
escribirLnea
fpara
fpara
sino
sino
escribir(No
escribir(No hay
hay solucin)
solucin)
fsi
fsi
fin
fin
J. Campos - C.P.S.

ajedrez
v
Resultado de la ejecucin:
Introduce i inicial: 1
Introduce j inicial: 1
1
60
39
34
31
38
35
32
61
10
59
2
37
40
33
36
49
42
27
62
43
58
3
50
41
48
51
46
55
26
57
44
53
4
23
52
47
56
45
54
18
63
28
11
24
21
14
5
9
30
19
16
7
12
25
22
Inconveniente de esta solucin:

su ineficiencia
(724 en un 68040LC 50/25 MHz)
(se visitan 8.250.733 nodos)
J. Campos - C.P.S.
64
17
8
29
20
15
6
13

ajedrez
v
Una heurstica voraz:

En cada escaque, seleccionar el siguiente a visitar
con la regla:
Se elige aquel escaque no visitado desde el cual se
puede acceder a un menor nmero de escaques no
visitados.
La heurstica se basa en la idea: si ahora tenemos
oportunidad de desplazarnos a un escaque muy
aislado debemos hacerlo, pues ms adelante
ser ms difcil llegar a l de nuevo.
El algoritmo resultante no es de bsqueda con
retroceso.
J. Campos - C.P.S.

ajedrez
funcin
funcin accesibles(ent
accesibles(ent x,y:entero)
x,y:entero)
devuelve
devuelve entero
entero
{Devuelve
{Devuelve el
el nmero
nmero de
de escaques
escaques no
no visitados
visitados
accesibles
accesibles desde
desde x,y.}
x,y.}
variables
variables k,u,v,num:entero
k,u,v,num:entero
principio
principio
num:=0;
num:=0;
para
para k:=1
k:=1 hasta
hasta 88 hacer
hacer
u:=x+dx[k];
u:=x+dx[k];
v:=y+dy[k];
v:=y+dy[k];
si
si (1
(1u)
u)(u
(un)
n)(1
(1v)
v)(v
(vn)
n)
entonces
entonces
si
si tab[u,v]=0
tab[u,v]=0
entonces
entonces num:=num+1
num:=num+1
fsi
fsi
fsi
fsi
fpara
fpara
devuelve
devuelve num
num
fin
fin
J. Campos - C.P.S.

ajedrez
algoritmo
algoritmo caballo
caballo
constante
constante n=8
n=8
variables
de entero;
entero;
de entero;
entero;
x,y,i,j,k,kk,u,v,num,menor:entero;
x,y,i,j,k,kk,u,v,num,menor:entero;
parar:booleano
parar:booleano
principio
principio
dx[1]:=2;
dx[1]:=2; dx[2]:=1;
dx[2]:=1; dx[3]:=-1;
dx[3]:=-1; dx[4]:=-2;
dx[4]:=-2;
dx[5]:=-2;
dx[6]:=-1;
dx[7]:=1;
dx[5]:=-2; dx[6]:=-1; dx[7]:=1; dx[8]:=2;
dx[8]:=2;
dy[1]:=1;
dy[1]:=1; dy[2]:=2;
dy[2]:=2; dy[3]:=2;
dy[3]:=2; dy[4]:=1;
dy[4]:=1;
dy[5]:=-1;
dy[5]:=-1; dy[6]:=-2;
dy[6]:=-2; dy[7]:=-2;
dy[7]:=-2; dy[8]:=-1;
dy[8]:=-1;
para
i:=1
hasta
n
hacer
para i:=1 hasta n hacer
para
para j:=1
j:=1 hasta
hasta nn hacer
hacer
tab[i,j]:=0
tab[i,j]:=0
fpara;
fpara;
fpara;
fpara;
escribir(Introduce
escribir(Introduce xx inicial:);
inicial:); leer(x);
leer(x);
escribir(Introduce
escribir(Introduce yy inicial:);
inicial:); leer(y);
leer(y);
tab[x,y]:=1;
tab[x,y]:=1;
i:=1;
i:=1;
parar:=falso;
parar:=falso;
...
...
J. Campos - C.P.S.

ajedrez
...
...
mq
mq (i<n*n)
(i<n*n) and
and not
not parar
parar hacer
hacer
i:=i+1;
i:=i+1; menor:=9;
menor:=9;
para
k:=1
para k:=1 hasta
hasta 88 hacer
hacer
u:=x+dx[k];
v:=y+dy[k];
si
si (1
(1u)
u)(u
(un)
n)(1
(1v)
v)(v
(vn)
n) entonces
entonces
si
si tab[u,v]=0
tab[u,v]=0 entonces
entonces
num:=accesibles(u,v);
num:=accesibles(u,v);
si
si num<menor
num<menor entonces
entonces
menor:=num;
menor:=num;
kk:=k
kk:=k
fsi
fsi
fsi
fsi
fsi
fsi
fpara;
fpara;
si
si menor=9
menor=9
entonces
entonces
parar:=verdad
parar:=verdad
sino
sino
x:=x+dx[kk];
x:=x+dx[kk];
y:=y+dy[kk];
y:=y+dy[kk];
tab[x,y]:=i
tab[x,y]:=i
fsi
fsi
fmq;
fmq;
...
...
J. Campos - C.P.S.

ajedrez
...
...
si
si not
not parar
parar
entonces
entonces
para
para i:=1
i:=1 hasta
hasta nn hacer
hacer
para
para j:=1
j:=1 hasta
hasta nn hacer
hacer
escribir(tab[i,j])
escribir(tab[i,j])
fpara;
fpara;
escribirLnea
escribirLnea
fpara
fpara
sino
sino
escribir(No
escribir(No encuentro
encuentro solucin)
solucin)
fsi
fsi
fin
fin
J. Campos - C.P.S.

ajedrez
v
Resultado de la ejecucin:
Introduce x inicial: 1
Introduce y inicial: 1
1
34
3
18
49
4
19
56
33
14
57
2
35
48
55
20
5
60
53
36
41
58
37
46
61
6
21
42
59
38
43
40
23
8
45
22
7
44
39
24
32
17
52
47
54
27
62
9
13
50
15
30
11
64
25
28
Mucho ms eficiente: (n2)

(menos de un segundo en el mismo computador)
(se visitan 64 nodos)
J. Campos - C.P.S.
16
31
12
51
26
29
10
63

ajedrez
v
Pero la heurstica voraz no funciona en

todos los casos:
Si n=5:
Introduce x inicial: 1
Introduce y inicial: 3
No encuentro solucin
(se visitan 17 nodos)
Sin embargo, si se ejecuta el algoritmo de
bsqueda con retroceso para n=5:
25
14
1
8
19
4
9
18
13
2
15
24
3
20
7
10
5
22
17
12
23
16
11
6
21
(se visitan 365.421 nodos)
(18 de ejecucin en el mismo computador)
J. Campos - C.P.S.

ajedrez
v
Solucin:
Mejorar el algoritmo de bsquedad con retroceso
cambiando el orden de ensayo de las casillas
accesibles desde una dada.
En lugar de ensayar de forma consecutiva en el
sentido de las agujas del reloj,
u se ensayar en primer lugar la casilla desde
la que se pueda acceder al menor nmero de
casillas no visitadas;
u si desde esa casilla no se llega a una
solucin, se intentar con la casilla con
siguiente menor nmero de casillas
accesibles no visitadas; etc.
Para poder implementar el retroceso:
u cada vez que se llegue a una casilla se
almacenan los movimientos posibles en una
cola de movimientos con prioridades,
donde la prioridad de un movimiento es el
nmero de casillas accesibles no visitadas
tras realizar ese movimiento
J. Campos - C.P.S.

ajedrez
v
Colas de movimientos con prioridades:

mdulo
mdulo colasMovPri
colasMovPri
exporta
exporta tipo
tipo mov
mov == registro
registro
valor:1..8;
valor:1..8;
peso:0..8
peso:0..8
freg
freg
{valor
{valor es
es el
el movimiento
movimiento segn
segn sentido
sentido de
de
las
agujas
del
reloj;
las agujas del reloj;
peso
peso es
es el
el n
n de
de casillas
casillas no
no visitadas
visitadas
accesibles
si
se
realiza
el
movimiento}
accesibles si se realiza el movimiento}
funcin
funcin menor(m1,m2:mov)
menor(m1,m2:mov) dev
dev booleano
booleano
principio
principio
devuelve
devuelve m1.peso<m2.peso
m1.peso<m2.peso
fin
fin
tipo
tipo cmp
cmp {tipo
{tipo opaco:
opaco: cola
cola de
de mov.
mov. con
con
prioridades;
prioridades; un
un mov.
mov. m1
m1 tiene
tiene
prioridad
sobre
otro
m2
si
prioridad sobre otro m2 si
menor(m1,m2)=verdad}
menor(m1,m2)=verdad}
algoritmo
algoritmo creaVaca(sal
creaVaca(sal c:cmp)
c:cmp)
algoritmo
algoritmo aadir(e/s
aadir(e/s c:cmp;
c:cmp; ent
ent m:mov)
m:mov)
funcin
funcin min(c:cmp)
min(c:cmp) devuelve
devuelve mov
mov
algoritmo
algoritmo eliminarMin(e/s
eliminarMin(e/s c:cmp)
c:cmp)
funcin
funcin esVaca(c:cmp)
esVaca(c:cmp) dev
dev booleano
booleano
implementacin
implementacin ...
...
fin
fin
J. Campos - C.P.S.

ajedrez
algoritmo
algoritmo ensaya(ent
ensaya(ent i,x,y:entero;
i,x,y:entero;
sal
xito:booleano)
sal xito:booleano)
{...}
{...}
variables
variables k,u,v:entero;
k,u,v:entero;
m:mov;
m:mov; cola:cmp
cola:cmp
principio
principio
{se
{se almacenan
almacenan los
los movimientos
movimientos posibles}
posibles}
creaVaca(cola);
creaVaca(cola);
para
para k:=1
k:=1 hasta
hasta 88 hacer
hacer
u:=x+dx[k];
v:=y+dy[k];
si
si (1
(1u)
u)(u
(un)
n)(1
(1v)
v)(v
(vn)
n) entonces
entonces
si
si tab[u,v]=0
tab[u,v]=0 entonces
entonces
m.valor:=k;
m.valor:=k; m.peso:=accesibles(u,v);
m.peso:=accesibles(u,v);
aadir(cola,m)
aadir(cola,m)
fsi
fsi
fsi
fsi
fpara;
fpara;
...
...
J. Campos - C.P.S.

ajedrez
...
...
{se
{se ensaya
ensaya por
por orden
orden de
de menor
menor aa mayor
mayor n
n de
de
casillas
accesibles
no
visitadas}
casillas accesibles no visitadas}
xito:=falso;
xito:=falso;
mq
mq not
not esVaca(cola)
esVaca(cola) and
and not
not xito
xito hacer
hacer
m:=min(cola);
m:=min(cola); eliminarMin(cola);
eliminarMin(cola);
k:=m.valor;
k:=m.valor;
u:=x+dx[k];
v:=y+dy[k];
tab[u,v]:=i;
tab[u,v]:=i;
si
si i<n*n
i<n*n
entonces
entonces
si
si not
not xito
xito
entonces
entonces tab[u,v]:=0
tab[u,v]:=0
fsi
fsi
sino
sino xito:=verdad
xito:=verdad
fsi
fsi
fmq
fmq
fin
fin
J. Campos - C.P.S.

ajedrez
v
El algoritmo resultante es mucho ms

eficiente que el original.
Y ahora s encuentra la solucin para el caso n=5:
23
6
1
16
21
12
17
22
7
2
5
24
11
20
15
10
13
18
3
8
25
4
9
14
19
(se visitan 1.734 nodos, en menos de un segundo)
J. Campos - C.P.S.

v
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 el beneficio.
maximizar
bixi
1i n
sujeto a
pixi C
1i n
con xi {0,1}, bi > 0, pi > 0, 1 i n
Soluciones a problemas parecidos:

Mochila con objetos fraccionables, es decir,
0xi1, 1in: solucin voraz.
Mochila 0-1 pero siendo los pesos, beneficios y
capacidad de la mochila nmeros naturales:
solucin de programacin dinmica.
Niguna de las dos soluciones funciona en el caso
general de la mochila 0-1.
J. Campos - C.P.S.

v
Espacio de soluciones:
2n modos de asignar los valores 0 1 a las xi.
Dos formas de representar la solucin: tuplas de
tamao fijo o variable.
Tuplas de tamao variable:
xi=objeto introducido en i-simo lugar
1
x1 =1
x1 =2
10
x2 =2
x2 =3 x =4
2
3
x3 =3
4
x3 =4 x3 =4
6
x1 =4
x1 =3
x2 =3 x2 =4
9
11 13
14
16
x2 =4
15
x3 =4
12
x4 =4
5
J. Campos - C.P.S.

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
x2 =0
10
x3 =0
x3 =1
x3 =0
18
x3 =1
11
12
14
13
15
25
x3 =0
x3 =1
19
x4 =1
x4 =1
x4 =1
x4 =1
x4 =0
x4 =0
x4 =0
x4 =0
x4 =0
5
x2 =1
16
20
x3 =0
22
x4 =1
x4 =0
21
23
26
x4 =1
x4 =0
24
27
29
x4 =1
x4 =0
28
Elegimos sta ltima representacin.
J. Campos - C.P.S.
x3 =1
30
x4 =1
31

v
Eleccin de funciones acotadoras:

intentar podar ramas que no puedan
producir soluciones mejores que la
disponible actualmente
se llama poda basada en el coste de la mejor
solucin en curso
calcular una cota superior del valor de la mejor
solucin posible al expandir un nodo y sus
descendientes
si esa cota es menor o igual que el valor de la
mejor solucin disponible hasta el momento, no
expandir ese nodo
cmo calcular esa cota superior?
u suponer que en el nodo actual ya se han
determinado xi, 1ik;
u relajar el requisito de integridad:
xi{0,1}, k+1in se sustituye por 0xi1,
k+1in
u aplicar el algoritmo voraz
J. Campos - C.P.S.

constante
constante n=...
n=... {nmero
{nmero de
de objetos}
objetos}
tipo
tipo vectReal=vector[1..n]
vectReal=vector[1..n] de
de real
real
{Pre: i1..n:peso[i]>0
i1..n-1:benef[i]/peso[i]benef[i+1]/peso[i+1]}
funcin
funcin cota(benef,peso:vectReal;
cota(benef,peso:vectReal;
cap,ben:real;
cap,ben:real; obj:entero)
obj:entero)
devuelve
devuelve real
real
{cap=capacidad
{cap=capacidad an
an libre
libre de
de la
la mochila;
mochila;
ben=beneficio
ben=beneficio actual;
actual;
obj=ndice
obj=ndice del
del primer
primer objeto
objeto aa considerar}
considerar}
principio
principio
si
si obj>n
obj>n or
or cap=0.0
cap=0.0
entonces
entonces devuelve
devuelve ben
ben
sino
sino
si
si peso[obj]>cap
peso[obj]>cap
entonces
entonces
dev
dev ben+cap/peso[obj]*benef[obj]
ben+cap/peso[obj]*benef[obj]
sino
sino
dev
dev cota(benef,peso,cap-peso[obj],
cota(benef,peso,cap-peso[obj],
ben+benef[obj],obj+1)
ben+benef[obj],obj+1)
fsi
fsi
fsi
fsi
fin
fin
J. Campos - C.P.S.

tipo
tipo solucin=vector[1..n]
solucin=vector[1..n] de
de 0..1
0..1
{variables
{variables globales:
globales:
benef,peso:vectReal;
benef,peso:vectReal; cap:real}
cap:real}
algoritmo
algoritmo bsqueda(ent
bsqueda(ent solAct:solucin;
solAct:solucin;
ent
ent benAct,pesAct:real;
benAct,pesAct:real;
ent
ent obj:entero;
obj:entero;
e/s
sol:solucin;
e/s sol:solucin;
e/s
e/s ben:real)
ben:real)
variable
variable decisin:0..1
decisin:0..1
principio
principio
para
para decisin:=0
decisin:=0 hasta
hasta 11 hacer
hacer
solAct[obj]:=decisin;
solAct[obj]:=decisin;
benAct:=benAct+decisin*benef[obj];
benAct:=benAct+decisin*benef[obj];
pesAct:=pesAct+decisin*peso[obj];
pesAct:=pesAct+decisin*peso[obj];
si
si pesAct
pesActcap
cap and
and ben<cota(benef,peso,
ben<cota(benef,peso,
cap-pesAct,benAct,obj+1)
cap-pesAct,benAct,obj+1) entonces
entonces
si
obj=n
si obj=n
entonces
entonces si
si benAct>ben
benAct>ben entonces
entonces
sol:=solAct;
sol:=solAct; ben:=benAct
ben:=benAct
fsi
fsi
sino
sino bsqueda(solAct,benAct,pesAct,
bsqueda(solAct,benAct,pesAct,
obj+1,sol,ben)
obj+1,sol,ben)
fsi
fsi
fsi
fsi
fpara
fpara
fin
fin
J. Campos - C.P.S.

algoritmo
algoritmo mochila01(ent
mochila01(ent benef,peso:vectReal;
benef,peso:vectReal;
ent
ent cap:real;
cap:real;
sal
sal sol:solucin;
sol:solucin;
sal
sal ben:real)
ben:real)
variables
variables obj:entero;
obj:entero; solAct:solucin
solAct:solucin
principio
principio
para
para obj:=1
obj:=1 hasta
hasta nn hacer
hacer
solAct[obj]:=0;
solAct[obj]:=0; sol[obj]:=0
sol[obj]:=0
fpara;
fpara;
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
J. Campos - C.P.S.

v
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
1
33
63
1
56
96
89 162.44
139
1
0
66
106
164.66
99
149
0
162
101
151
0
139
149
J. Campos - C.P.S.
151
159.79
0
154.88
0
68
108
0
0 157.55
1161.63 0
163.81
0
35
65
109
159
159.76
155.11
157.44
160.22
157.11
159.33
158
157.63
160.18
159
ben=159
sol=(1,1,1,0,1,1,0,0)

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(...)
J. Campos - C.P.S.

v
Hasta ahora hemos visto algoritmos de

bsqueda con retroceso basados en
rbol de espacio de estados esttico.
Se pueden disear algoritmos basados

en rboles de espacio de estados
dinmicos.
J. Campos - C.P.S.

v
Solucin del problema de la mochila 0-1

basada en un rbol dinmico:
Resolver el problema sin la restriccin de
integridad (con el algoritmo voraz):
maximizar bi xi
1i n
sujeto a
pixi C
(*)
1i n
con 0 xi 1, 1 i n
Si la solucin obtenida es entera (0-1),

tambin es ptima para el problema 0-1.
u Si no es entera, existe exactamente un xi tal
que 0<xi<1.
Se parte el espacio de soluciones en dos
subespacios: en uno (subrbol izquierdo)
xi=0 y en otro (subrbol derecho) xi=1.
En general, en cada nodo del rbol, se usa el
algoritmo voraz para resolver el problema (*) con
las restricciones aadidas correspondientes a las
asignaciones ya realizadas a lo largo del camino
desde la raz al nodo.
u Si la solucin es entera, ya se tiene el ptimo
para ese nodo.
u Si no lo es, existe exactamente un xi tal que
0<xi<1, etc.
u
J. Campos - C.P.S.
Reconstruccin de puntos a
partir de las distancias
v
Clculo de las distancias a partir de un

conjunto de puntos:
Se tienen n puntos distintos localizados en el eje
x, con coordenadas x1, x2, , xn, de forma que
x1=0 y que x1<x2<<xn.
Esos n puntos determinan m=n(n-1)/2 distancias
d1, d2, , dm, entre cada par de puntos (xi-xj, i>j).
Dado el conjunto de puntos, es fcil construir el
conjunto de distancias en tiempo O(n2).
Ms an, en tiempo O(n2log n), se puede
construir el conjunto de distancias ordenado.
Problema inverso: clculo de las

coordenadas de los puntos a partir de
las distancias (si existen).
Tiene aplicaciones en fsica y biologa molecular.
No se conoce todava un algoritmo que lo
resuelva en tiempo polinmico.
El algoritmo que vamos a presentar parece
comportarse en tiempo O(n2log n), pero ni se ha
demostrado esta conjetura ni se ha encontrado
un contraejemplo.
J. Campos - C.P.S.
v
Veamos un ejemplo:
D={1,2,2,2,3,3,3,4,5,5,5,6,7,8,10}
Como |D|=m=n(n-1)/2, n=6.
Se fija x1=0 (por ejemplo).
Claramente, x6=10, porque 10 es el mximo de D.
x1=0
x6=10
D={1,2,2,2,3,3,3,4,5,5,5,6,7,8}
La distancia mayor restante es 8, luego x2=2 o

x5=8. Por simetra, puede observarse que ambas
elecciones dan una misma solucin (en realidad,
una da la imagen especular de la otra) o no dan
solucin. Tomamos x5=8.
Se borran las distancias x6-x5=2 y x5-x1=8 de D.
x1=0
x5=8
D={1,2,2,3,3,3,4,5,5,5,6,7}
J. Campos - C.P.S.
x6=10
El siguiente valor ms grande de D es 7 luego,
x4=7 o x2=3.
u Si x4=7, las distancias x6-7=3 y x5-7=1
tambin deben estar en D. Lo estn.
x1=0
x4=7 x5=8
x6=10
D={2,2,3,3,4,5,5,5,6}
La distancia mayor es ahora 6, as que x3=6 o
x2=4.
Pero si x3=6, entonces x4-x3=1, lo cual es
imposible porque 1 ya no est en D.
Y si x2=4, entonces x2-x1=4 y x5-x2=4, lo cual
tambin es imposible porque 4 slo aparece
una vez en D.
Retroceso...
J. Campos - C.P.S.
u
Si x2=3, las distancias 3-x1=3 y x5-3=5

tambin deben estar en D. Lo estn.
x1=0
x2=3
x5=8
x6=10
D={1,2,2,3,3,4,5,5,6}
Ahora hay que escoger entre x4=6 o x3=4.
x3=4 es imposible porque D slo tiene una
ocurrencia de 4 y haran falta dos.
x4=6 s es posible.
x1=0
x2=3
x4=6
x5=8
x6=10
D={1,2,3,5,5}
La nica eleccin que queda es x3=5:
x1=0
x2=3
x3=5 x4=6
x5=8
D={}
Y se ha llegado a una solucin.
J. Campos - C.P.S.
x6=10
El rbol asociado al proceso anterior es:
x1=0,x6=10
x5=8
x4=7**
x3=6*
x2=4*
x2=3
x3=4*
x4=6
x3=5
(*) indica que los puntos elegidos son inconsistentes

con las distancias dadas
(**) indica que ese nodo tiene dos nodos imposibles
como hijos (luego es un camino incorrecto)
J. Campos - C.P.S.
tipos
tipos saco
saco == multiconjunto
multiconjunto de
de entero;
entero;
sol
sol == vector[1..n]
vector[1..n] de
de entero
entero
algoritmo
algoritmo reconstruir(ent
reconstruir(ent D:saco;
D:saco;
sal
x:sol;
sal x:sol;
sal
sal xito:booleano)
xito:booleano)
{Pre:
{Pre: |D|=n(n-1)/2}
|D|=n(n-1)/2}
principio
principio
xito:=falso;
xito:=falso;
x[1]:=0;
x[1]:=0;
x[n]:=mximo(D);
x[n]:=mximo(D);
eliminarMx(D);
eliminarMx(D);
x[n-1]:=mximo(D);
x[n-1]:=mximo(D);
eliminarMx(D);
eliminarMx(D);
si
si x[n]-x[n-1]
x[n]-x[n-1]DD
entonces
entonces
eliminar(x[n]-x[n-1],D);
eliminar(x[n]-x[n-1],D);
colocar(x,D,2,n-2,xito)
colocar(x,D,2,n-2,xito)
sino
sino
xito:=falso
xito:=falso
fsi
fsi
fin
fin
J. Campos - C.P.S.
algoritmo
algoritmo colocar(e/s
colocar(e/s x:sol;
x:sol; e/s
e/s D:saco;
D:saco;
ent
ent iz,de:entero;
iz,de:entero;
sal
sal xito:booleano)
xito:booleano)
{Algoritmo
{Algoritmo de
de bsqueda
bsqueda con
con retroceso
retroceso para
para colocar
colocar
los
puntos
x[iz]..x[de].
los puntos x[iz]..x[de].
x[1]..x[iz-1]
x[1]..x[iz-1] yy x[de+1]..x[n]
x[de+1]..x[n] ya
ya se
se han
han colocado
colocado
provisionalmente.}
provisionalmente.}
variable
variable maxD:entero
maxD:entero
principio
principio
si
si D=
D= entonces
entonces xito:=verdad
xito:=verdad
sino
sino
maxD:=mximo(D);
maxD:=mximo(D);
{comprueba
{comprueba si
si es
es factible
factible x[de]=maxD}
x[de]=maxD}
si
si |x[j]-maxD|
|x[j]-maxD|D,
D, 11j<iz,
j<iz, de<j
de<jnn entonces
entonces
x[de]:=maxD;
x[de]:=maxD; {intenta
{intenta x[de]=maxD}
x[de]=maxD}
para
para 11j<iz,de<j
j<iz,de<jnn hacer
hacer
eliminar(|x[j]-maxD|,D)
eliminar(|x[j]-maxD|,D)
fpara;
fpara;
colocar(x,D,iz,de-1,xito);
colocar(x,D,iz,de-1,xito);
si
si not
not xito
xito entonces
entonces {retroceso}
{retroceso}
para
para 11j<iz,de<j
j<iz,de<jnn hacer
hacer
{deshace
{deshace la
la eliminacin}
eliminacin}
insertar(|x[j]-maxD|,D)
insertar(|x[j]-maxD|,D)
fpara
fpara
fsi
fsi
fsi;
fsi;
...
...
J. Campos - C.P.S.
...
...
{Si
{Si fall
fall el
el primer
primer intento,
intento, se
se intenta
intenta ver
ver si
si
x[iz]=x[n]-maxD}
x[iz]=x[n]-maxD}
si
si not
not xito
xito and
and |x[n]-maxD-x[j]|
|x[n]-maxD-x[j]|D,
D,
11j<iz,
j<iz, de<j
de<jnn entonces
entonces
x[iz]:=x[n]-maxD;
x[iz]:=x[n]-maxD;
para
para 11j<iz,de<j
j<iz,de<jnn hacer
hacer
eliminar(|x[n]-maxD-x[j]|,D)
eliminar(|x[n]-maxD-x[j]|,D)
fpara;
fpara;
colocar(x,D,iz+1,de,xito);
colocar(x,D,iz+1,de,xito);
si
si not
not xito
xito entonces
entonces {retroceso}
{retroceso}
para
para 11j<iz,de<j
j<iz,de<jnn hacer
hacer
{deshace
{deshace la
la eliminacin}
eliminacin}
insertar(|x[n]-maxD-x[j]|,D)
insertar(|x[n]-maxD-x[j]|,D)
fpara
fpara
fsi
fsi
fsi
fsi
fsi
fsi
fin
fin
J. Campos - C.P.S.
v
Anlisis de la eficiencia:
Caso fcil: No se realiza ningn retroceso.
u
Hay como mximo O(n2) operaciones de

eliminar un elemento de D.
En efecto, porque no se realiza ninguna
insercin en D e inicialmente tiene O(n2)
elementos.
Hay como mximo O(n2) operaciones de
bsqueda () de un elemento.
En efecto, en cada ejecucin de colocar hay
como mximo 2n bsquedas y colocar se
ejecuta O(n) veces (si no hay retrocesos).
Si D se guarda en un rbol AVL, el coste de
las operaciones de eliminar y buscar es
O(log n).
el coste es O(n2log n)
J. Campos - C.P.S.
En general, ocurren retrocesos, y:
u
No se conoce ninguna cota polinmica del

nmero de retrocesos (luego, en principio,
no se conoce ninguna solucin polinmica).
Sin embargo:
u
No se conoce ningn ejemplo en el que el

nmero de retrocesos sea mayor que O(1) !
Luego, es posible que el algoritmo sea O(n2log n).

Por ejemplo, se ha demostrado que si los n
puntos se generan de acuerdo con una
distribucin uniforme en el intervalo [0,max],
con max=(n2), entonces con probabilidad 1 se
efecta como mximo un retroceso durante todo
el algoritmo.
J. Campos - C.P.S.

v
Estudio de ciertos juegos de estrategia

que pueden representarse mediante
rboles:
cada nodo se corresponde con una configuracin posible del juego (por ejemplo, estado de un
tablero), y
cada arco es una transicin legal, o jugada, desde
una configuracin posible a una de sus
sucesoras.
Por simplificar, consideremos que:

hay dos jugadores que juegan alternadamente,
los dos jugadores estn sometidos a las mismas
reglas (juego simtrico),
el azar no interviene (juego determinista),
una partida no puede durar indefinidamente, y
ninguna configuracin tiene un nmero infinito
de posibles sucesoras.
J. Campos - C.P.S.

La configuracin inicial del juego es la raz del
rbol correspondiente.
Las hojas del rbol corresponden a las configuraciones terminales del juego, en las que no existe
jugada siguiente
u
u
bien porque uno de los jugadores ha ganado

bien porque no ha ganado ninguno
(situacin de empate)
Los niveles impares del rbol estn asociados con

las configuraciones en las que debe jugar uno de
los dos jugadores, mientras que los niveles pares
se asocian a las configuraciones en las que debe
jugar el otro.
J. Campos - C.P.S.

A cada nodo del rbol se le asocia una etiqueta
llamada funcin de utilidad.
Por ejemplo, una funcin de utilidad habitual
toma tres valores posibles:
u
u
u
configuracin ganadora,
configuracin perdedora y
configuracin empatadora o nula.
Interpretacin:
Situacin (o posibilidades) que tiene el jugador
(tomamos partido por uno de ellos) en esa configuracin, suponiendo que ninguno de los dos
jugadores se equivocar y ambos realizarn en lo
sucesivo la mejor jugada posible.
La funcin de utilidad puede asignarse de forma
sistemtica.
J. Campos - C.P.S.

v
Ejemplo: el juego del tic-tac-toe.

Una especie de tres en raya con ms de tres
fichas por jugador.
Llamaremos a los dos jugadores l y yo.
Supondremos, por ejemplo, que empieza yo.
El rbol tiene la forma siguiente:
funcin de
utilidad empatadora
nivel 0
mueve yo
yo
yol
l
l
funcin de
utilidad ganadora
yo
nivel 6
mueve yo
yo yo yo
yo l
nivel 7
mueve l
yo
yo
yo yol
funcin de
utilidad perdedora
yo
-1
yo
yo l
l yo l
GANA yo
nivel 8
mueve yo
yo l yo
yo yo l
l
yo
yo
yo yo l
l l l
-1
yo l yo
yo l
l yo l
yo
yo
l yo l
l yo l
GANA l
nivel 9
J. Campos - C.P.S.
yo l yo
yo yo l
yo l yo
yo yo l
yo yo yo
l yo l
l yo l
l yo l
l yo l
EMPATE
EMPATE
GANA yo

v
Clculo de la utilidad:
Se da valor, en primer lugar, a las hojas:
u la utilidad en una hoja vale 1, 0 -1 si la
configuracin del juego corresponde a una
victoria, empate o derrota, respectivamente,
del jugador por el que hemos tomado
partido (yo).
Los valores de la funcin de utilidad se
propagan hacia arriba del rbol de acuerdo a la
siguiente regla (estrategia minimax):
u si un nodo corresponde a una configuracin
del juego en la que juega yo (nivel 0
par), se supone que ese jugador har la
mejor jugada de entre las posibles y, por
tanto, el valor de la funcin de utilidad en la
configuracin actual coincide con el valor de
esa funcin en la configuracin de la mejor
jugada posible (para yo) que se puede
realizar desde la actual (nodo max);
u si un nodo corresponde a una configuracin
del juego en la que juega l (nivel impar
del rbol), se supone que ese jugador har la
mejor jugada de entre las posibles y, por
tanto, el valor de la funcin de utilidad en la
configuracin actual coincide con el valor de
esa funcin en la configuracin de la peor
jugada posible (para yo) (nodo min).
J. Campos - C.P.S.

Si la raz tuviera el valor 1, entonces yo tendra
una estrategia que le permitira ganar siempre
(no es el caso del tic-tac-toe).
En el tic-tac-toe la funcin de utilidad de la raz
vale 0 (ningn jugador tiene una estrategia
ganadora):
si no se cometen errores, se puede garantizar
al menos un empate.
Si la raz tuviera un valor -1, el otro jugador
(l) tendra una estrategia ganadora.
J. Campos - C.P.S.

La funcin de utilidad puede tener un rango ms
amplio (por ejemplo, los nmeros enteros).
Ejemplo: Ajedrez
u se ha estimado que el rbol del juego tiene
ms de 10100 nodos
u si un computador pudiera generar 1011
nodos por segundo, necesitara ms de 1080
aos para construirlo
u es imposible dar valor a la funcin de
utilidad de cada nodo de abajo hacia arriba
(como en el caso del tic-tac-toe)
u para cada configuracin actual del juego, se
toma dicha configuracin como raz del
rbol
u se construyen varios niveles del rbol
(el nmero depende de la velocidad del
computador o puede ser seleccionado por el
usuario)
u la mayor parte de las hojas del rbol construido son ambiguas (no indican triunfos,
derrotas ni empates)
u la funcin de utilidad de las posiciones del
tablero intenta estimar la probabilidad de
que el computador gane desde esa posicin
J. Campos - C.P.S.

v
Implementacin () detallada:
representacin de una configuracin del juego
(definicin del tipo de dato configuracin)
enumeracin de las configuraciones accesibles
desde una dada mediante la ejecucin de una
jugada, y
clculo de la funcin de utilidad para una
configuracin dada, sabiendo quin juega en ese
momento
J. Campos - C.P.S.

algoritmo
algoritmo juegaElComputador(e/s
juegaElComputador(e/s c:config)
c:config)
{c
{c es
es una
una configuracin
configuracin no
no final;
final; el
el algoritmo
algoritmo
realiza
realiza la
la mejor
mejor jugada
jugada posible
posible aa partir
partir de
de c,
c,
la
comunica
al
usuario
y
actualiza
c}
la comunica al usuario y actualiza c}
variables
variables maxUtilidad,laUtilidad:entero;
maxUtilidad,laUtilidad:entero;
i:1..maxEntero;
i:1..maxEntero;
mejorJugada,unaJugada:config
mejorJugada,unaJugada:config
principio
principio
i:=1;
i:=1;
{clculo
{clculo de
de la
la 1
1 config.
config. accesible
accesible desde
desde c}
c}
jugada(c,i,unaJugada);
mejorJugada:=unaJugada;
maxUtilidad:=utilidad(mejorJugada,falso);
maxUtilidad:=utilidad(mejorJugada,falso);
{"falso"
{"falso" indica
indica que
que cuando
cuando la
la configuracin
configuracin
sea
sea "mejorJugada",
"mejorJugada", no
no juego
juego yo}
yo}
mq
mq not
not esLaUltimaJugada(c,i)
esLaUltimaJugada(c,i) hacer
hacer
i:=i+1;
i:=i+1;
laUtilidad:=utilidad(unaJugada,falso);
laUtilidad:=utilidad(unaJugada,falso);
si
si laUtilidad>maxUtilidad
laUtilidad>maxUtilidad entonces
entonces
maxUtilidad:=laUtilidad
maxUtilidad:=laUtilidad
fsi
fsi
fmq;
fmq;
comunicaAlUsuario(mejorJugada);
comunicaAlUsuario(mejorJugada);
c:=mejorJugada
c:=mejorJugada
fin
fin
J. Campos - C.P.S.

algoritmo
algoritmo jugada(ent
jugada(ent c:config;
c:config;
ent
ent i:1..maxEntero;
i:1..maxEntero;
sal
sal unaJugada:config)
unaJugada:config)
{Pre:
{Pre: cc admite
admite al
al menos
menos ii jugadas
jugadas diferentes.}
diferentes.}
{Post:
unaJugada
es
la
i-sima
jugada
{Post: unaJugada es la i-sima jugada posible
posible
desde
c.}
desde c.}
...
...
algoritmo
algoritmo esLaltimaJug(ent
esLaltimaJug(ent c:config;
c:config;
ent
ent i:0..maxEntero)
i:0..maxEntero)
devuelve
devuelve booleano
booleano
{Devuelve
{Devuelve verdad
verdad si
si yy slo
slo si
si cc admite
admite
exactamente
i
jugadas
diferentes.}
exactamente i jugadas diferentes.}
...
...
algoritmo
algoritmo comunicaAlUsuario(ent
comunicaAlUsuario(ent c:config)
c:config)
{Muestra
{Muestra en
en pantalla
pantalla la
la configuracin
configuracin c.}
c.}
...
...
algoritmo
algoritmo utilidadFinal(ent
utilidadFinal(ent c:config)
c:config)
devuelve
devuelve entero
entero
{Pre:
{Pre: cc es
es una
una configuracin
configuracin final
final del
del juego.}
juego.}
{Post:
{Post: devuelve
devuelve la
la utilidad
utilidad de
de c.}
c.}
...
...
J. Campos - C.P.S.

algoritmo
algoritmo utilidad(ent
utilidad(ent c:config;
c:config;
ent
ent juegoYo:booleano)
juegoYo:booleano)
devuelve
devuelve entero
entero
{Calcula
{Calcula la
la utilidad
utilidad de
de cc teniendo
teniendo en
en cuenta
cuenta
quin
juega.}
quin juega.}
variables
variables laUtilidad:entero;
laUtilidad:entero;
i:1..maxEntero;
i:1..maxEntero;
unaJugada:config
unaJugada:config
principio
principio
si
si esLaUltimaJug(c,0)
esLaUltimaJug(c,0)
entonces
entonces
devuelve
devuelve utilidadFinal(c)
utilidadFinal(c)
sino
sino
i:=1;
i:=1;
laUtilidad:=
laUtilidad:=
utilidad(unaJugada,not
utilidad(unaJugada,not juegoYo);
juegoYo);
...
...
J. Campos - C.P.S.

...
...
mq
mq not
not esLaUltimaJug(c,i)
esLaUltimaJug(c,i) hacer
hacer
i:=i+1;
i:=i+1;
si
si juegoYo
juegoYo
entonces
entonces
laUtilidad:=
laUtilidad:=
max(laUtilidad,
max(laUtilidad,
utilidad(unaJugada,falso))
utilidad(unaJugada,falso))
sino
sino
laUtilidad:=
laUtilidad:=
min(laUtilidad,
min(laUtilidad,
utilidad(unaJugada,verdad))
utilidad(unaJugada,verdad))
fsi
fsi
fmq;
fmq;
devuelve
devuelve laUtilidad
laUtilidad
fsi
fsi
fin
fin
J. Campos - C.P.S.

v
Sobre el tamao del rbol:

Si empieza el computador, se examinan
97162 nodos.
Si el computador juega en segundo lugar:
u se examinan 5185, si el jugador humano
coloc primero en el centro,
u se examinan 9761, si el humano coloc en
una esquina,
u se examinan 13233, si el humano coloc en
una casilla que no es ni el centro ni una
esquina.
Se precisan mtodos para evaluar

menos nodos sin perder informacin
El ms conocido es el mtodo de
poda
J. Campos - C.P.S.

v
Poda :
nodo max
nodo min
=20
c2 =15
c1 20
c3
15
Una vez que se encuentra el descendiente d de c2,

no es necesario seguir calculando descendientes
de c2 (porque c2 es un nodo min, tendr un
valor menor o igual a 15, y su padre es max y
ya tiene un valor mayor o igual a 20).
J. Campos - C.P.S.

v
Poda :
nodo min
nodo max
=44
c2 =68
c1 44
c3
68
Una vez que se encuentra el descendiente d de c2,

no es necesario seguir calculando descendientes
de c2 (porque c2 es un nodo max, tendr un
valor mayor o igual a 68, y su padre es min y
ya tiene un valor menor o igual a 44).
J. Campos - C.P.S.

v
Resultados prcticos:
La poda restringe la bsqueda a O( n )
nodos (si el nmero original es n).
Este ahorro es muy grande y supone que las
bsquedas que usan la poda pueden ir al
doble de la profundidad en comparacin con un
rbol no podado.
En el ejemplo del tic-tac-toe, el nmero inicial de
97162 nodos se reduce a 4493.
J. Campos - C.P.S.

5-Busqueda Con Retroceso PDF

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

5-Busqueda Con Retroceso PDF

Cargado por

Copyright:

Formatos disponibles

Bsqueda con retroceso

Esquemas algortmicos - Bsqueda con retroceso

Bsqueda con retroceso:

Problemas que consideraremos:

Esquemas algortmicos - Bsqueda con retroceso

Bsqueda con retroceso:

Planteamiento del problema:

n-tuplas candidatas para satisfacer P.

Esquemas algortmicos - Bsqueda con retroceso

Bsqueda con retroceso:

Esquemas algortmicos - Bsqueda con retroceso

Bsqueda con retroceso:

Ejemplo: el problema de las ocho reinas

Esquemas algortmicos - Bsqueda con retroceso

Bsqueda con retroceso:

Esquemas algortmicos - Bsqueda con retroceso

Bsqueda con retroceso:

Volviendo al planteamiento general:

En el ejemplo, para el problema de las

El espacio de soluciones est definido por todos los

Esquemas algortmicos - Bsqueda con retroceso

Bsqueda con retroceso:

Esquemas algortmicos - Bsqueda con retroceso

Bsqueda con retroceso:

La llamada inicial es:

Esquemas algortmicos - Bsqueda con retroceso

Bsqueda con retroceso:

En el ejemplo de las cuatro reinas:

(16 nodos frente a

Esquemas algortmicos - Bsqueda con retroceso

Bsqueda con retroceso:

Esquemas algortmicos - Bsqueda con retroceso

Bsqueda con retroceso:

Esquemas algortmicos - Bsqueda con retroceso

Bsqueda con retroceso:

Esquemas algortmicos - Bsqueda con retroceso

Bsqueda con retroceso:

Esquemas algortmicos - Bsqueda con retroceso

Bsqueda con retroceso:

Esquemas algortmicos - Bsqueda con retroceso

El problema de las ocho reinas

Esquemas algortmicos - Bsqueda con retroceso

El problema de las ocho reinas

Evaluacin del predicado acotador:

Esquemas algortmicos - Bsqueda con retroceso

El problema de las ocho reinas

Esquemas algortmicos - Bsqueda con retroceso

El problema de las ocho reinas

Esquemas algortmicos - Bsqueda con retroceso

El problema de las ocho reinas

Esquemas algortmicos - Bsqueda con retroceso

El problema de las ocho reinas

Estimacin del coste:

Con cada eleccin se guarda el nmero de

Esquemas algortmicos - Bsqueda con retroceso

El problema de las ocho reinas

Por tanto, nicamente se recorrera un 234% del

En este caso, la estimacin es algo optimista pues

Nmero de soluciones para n=8: 92.

Para encontrar soluciones no equivalentes, el

Esquemas algortmicos - Bsqueda con retroceso

El problema de las ocho reinas

Por ejemplo, n=12: