Back Tracking 1193073889558994 4

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.

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
n
t!
ti
i !1
n-tuplas candidatas para satisfacer Sol. Mtodo de fuerza bruta: examinar las t n-tuplas 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.

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+1vvtn tuplas que comienzan por (x1,,xi) Para saber si una n-tupla es solucin, suele haber dos tipos de restricciones: explcitas: describen el conjunto Ci de 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).

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

Formulacin 1: 64 ! 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 4v4):

algoritmo BackTracking(ent k:entero; entsal X:vector[1..n]de valor)
{Pre: X[1..k-1] es completable}
variable v:valor para todo v en Ci hacer X[k]:=v; si completable(X,k) entonces si Sol(X,k) entonces guardar(X,k) fsi; si k<n entonces BackTracking(k+1,X) fsi; fsi fpara
La llamada inicial es: ... BackTracking(1,X); ...

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).

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

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) v n) nodos a generar en total Normalmente: O(p(n) v 2n) O(p(n) v 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:
i

t r y
eje
Implicitas:
i { j xi { x j
k
w xi
i!1
!M n
xi
xi 1 , 1 e i

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: xi = 0 si wi no se elige y 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.

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 todos los caminos desde la raz hasta cualquier hoja del rbol.
1
x1=1
2
x1=2
3
x1=4 x1=3
4 5
x2=2 x2=3 x =4 2
6 7 8
x2=3 x2=4
9 10
x2=4
11
x3=3
x3=4 x3=4
14
x3=4
15
12 13
x4=4
16

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
2
x1=0
3
x2=1
18
x2=0
19
x2=1
4
x2=0
5
x3=1
26
x3=0
27
x3=1
20
x3=0
21
x3=1
12
x3=0
13
x3=1
6
x3=0
7
x4=1
30
x4=0 x4=0 x4=0 x4=0 x4=1 x4=1 x4=1 x4=1

31 28 29 24 25 22 23 16
x4=0 x4=1
17 14
x4=0 x4=1
15 10
x4=0 x4=1
11 8
x4=0
9

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:

algoritmo sumasub(ent s,k,r:entero; entsal X: vector[1..n]de nat)
{k: siguiente variable a decidir Los w[j] estn en orden creciente s=
-1 j 1 w[j]*x[j]; r=
w[j]
s+w[k]eM; s+ }
X[k]:=1; si s+w[k]=M entonces escribir(X[1..k]) sino si s+w[k]+w[k+1]eM entonces sumasub(s+w[k],k+1,r-w[k],X) fsi fsi si (s+r-w[k] u M) y (s+w[k+1] e M) entonces X[k]:=0; sumasub(s,k+1,r-w[k],X) fsi fin
1 w[i]uM

La llamada inicial es: ... sumasub(0,1, ...
i =1w[i])
Ntese que el algoritmo evita calcular
i =1 w[ i ]x[ i ]
i =k +1 w[ i ]
cada vez guardando esos valores en s y r. A esto se le llama MARCAJE. Coste: n con marcaje: O(2 )

sin marcaje: O(n 2n)

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 27-1=127)
0,1,73
x[1]=1
5,2,68
x[2]=1 x[2]=0
0,2,68 5,3,58 10,3,58

x[3]=0
15,3,58
x[3]=1 x[3]=0
0,3,58 12,4,46 12,5,33 0,4,46 13,5,33 13,6,18 0,5,33
x[3]=1
27,4,46
15,4,46 15,5,33
x[5]=1
17,4,46
x[4]=1
5,4,46
x[4]=0
10,4,46 10,5,33
x[4]=0
5,5,33 20,6,18
x[5]=1
12,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 4 2 1 3 5 4 5 2 3
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 de colores. Espacio de estados para n=3 y m=3.
x[1]=1
x[1]=2
x[1]=3
x[2]=1 x[2]=2 x[3]=1 x[3]= 3
x[2]=3
x[3] =2
Coloreado de grafos
algoritmo m_col(ent k:entero; entsal X:vector[1..n]de nat)
{Se usa una variable global g de tipo grafo.}
para v:=1..m hacer

X[k]:=v
si completable(X,k) entonces si k=n entonces escribir(X) sino m_col(k+1,X) fsi fsi fpara fin funcion Completable(entsal x:sol; ent k:entero) variables b:booleano; j:entero b:=verdad; j:=1; mientras (j<k) b hacer si g[k,j] y (x[k]=x[j]) entonces b:=falso sino j:=j+1 fsi fmientras retorna(b)
Ciclos hamiltonianos

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, vi{vj, 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 8 2 7 3 6 4 5
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,,xk1 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. algoritmo hamiltoniano(ent k:entero; entsal X:vector[1..n] de nat)
{Se usa una variable global g de tipo grafo.}
para v:=1..n hacer X[k]:=v; si completable(k,X) entonces si k=n entonces escribir(X) sino hamiltoniano(k+1,X) fsi fsi fpara funcion completable(ent k:entero; ent X:vector[1..n] de nat)
b:=g[X[k-1],X[k]];
para i:=1..k-1 mientras b hacer si X[i]=X[k] entonces b:=falso fsi fpara si k=n g[X[n],X[1]] entonces b:=falso fsi retorna b
x[1]:=1; hamiltoniano(2,x);
Atravesar un laberinto

Problema:
Nos encontramos en una entrada de un laberinto y debemos intentar atravesarlo.
Representacin: matriz de dimensin nvn 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 N MN < < M < < < N< <
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.
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 casilla = (libre,pared,camino,imposible) laberinto = vector[1..n,1..n] de casilla
Solucin de bsqueda ... HayCamino(1,1,lab) ...
con retroceso:
funcion HayCamino(ent x,y:entero; entsal lab:laberinto) {Pre: Hemos encontrado un camino desde (1,1) hasta (x,y). Post: Devuelve cierto ssi se puede extender hasta (n,n)}
funcion HayCamino(ent x,y:entero; entsal lab:laberinto) {devuelve cierto ssi existe camino} si (x<1)(x>n)(y<1)(y>n) lab[x,y]{libre entonces devuelve falso sino lab[x,y]:=camino; si (x=n)(y=n) entonces escribir(lab); devuelve cierto; sino b:= HayCamino(x+1,y,lab) HayCamino(x,y+1,lab) HayCamino(x-1,y,lab) HayCamino(x,y-1,lab); si b entonces lab[x,y]:= imposible; fsi devuelve b; fsi fsi 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 el beneficio.
maximizar sujeto a
bi xi
1ei en
pi xi
1ei en
eC
con xi {0,1} , bi " 0, pi " 0, 1 e i e n
Es el primer problema de optimizacin que vamos a resolver con Backtracking.

Tuplas de tamao fijo: xi=0 si el objeto i-simo no se introduce xi=1 si el objeto se introduce
1
x1=0
2
x1=1
17
x2=0
3
x2=1
10
x2=0
18
x2=1
25
x3=0
4
x3=1
7
x3=0
11
x3=1
14
x3=0
19
x3=1
22
x3=0
26
x3=1
29
x4=1 x4=1 x4=1 x4=1 x4=0 x4=0 x4=0 x4=0 x4=0

5 6 8 9 12 13 15 16 20
x4=1 x4=0
21 23
x4=1 x4=0
24 27
x4=1 x4=0
28 30
x4=1
31
Elegimos sta ltima representacin.

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)


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) u c(X,k), para todo X[1..k-1] Si cota(X,k) e 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}, kei en se sustituye por 0exi e1, keien aplicar el algoritmo voraz

tipo vectReal=vector[1..n] de real
{Pre: i1..n:peso[i]>0, benef[i]>0, i1..n-1:benef[i]/peso[i]ubenef[i+1]/peso[i+1]}
funcin cota(benef,peso:vectReal; cap,ben:real; k:entero) devuelve real

{cap=capacidad an libre de la mochila; ben=beneficio actual; k=ndice del primer objeto a considerar}
principio si k>n or cap=0.0 entonces devuelve ben sino si peso[k]>cap entonces dev ben+cap/peso[k]*benef[k] sino dev cota(benef,peso,cap-peso[k], ben+benef[k],k+1) fsi fsi fin

tipo solucin=vector[1..n] de 0..1
{variables globales: benef,peso:vectReal; cap:real}
algoritmo bsqueda(ent solAct:solucin; ent benAct,pesAct:real; ent k:entero; e/s sol:solucin; e/s ben:real) para v:=1 hasta 0 hacer solAct[k]:=v; benAct:=benAct+v*benef[k]; pesAct:=pesAct+v*peso[k]; si pesActecap ben<cota(benef,peso, cap-pesAct,benAct,k+1) entonces si k=n entonces si benAct>ben entonces sol:=solAct; ben:=benAct fsi sino bsqueda(solAct,benAct,pesAct, k+1,sol,ben) fsi fsi fpara fin

algoritmo mochila01(ent benef,peso:vectReal; ent cap:real; sal sol:solucin; sal ben:real) variables obj:entero; solAct:solucin principio ben:=0.0; bsqueda(solAct,0.0,0.0,1,sol,ben) 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.

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 12 32 1 33 63 0 1 11 0 0
155.11
157.44 159.76
1 56 96 1 0 89 162.44 139 1 0
1 35 65 0 1 68 108 0 157.55 0 0
160.22
1 66 106 0 1 109 159 1161.63 0 0 101 151 0
154.88 157.11
164.66
0
99 149 0
159.79
0
159.33 157.63
163.81
0 0
158
0
162
160.18
139 149 151 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(...)
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) u 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

algoritmo BackTracking(ent k:entero; entsal X:vector[1..n]de valor)
{Pre: X[1..k-1] es completable, c(X,k-1)<MS}
para todo v en Ci hacer X[k]:=v; si (completable(X,k) c(X,k)<MS) entonces si Sol(X,k) entonces MejorSol:= X; MS:= Coste(X) fsi; si k<n entonces BackTracking(k+1,X) fsi; fsi 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 nreinas 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
algoritmo n-reinas(ent k:entero; ent L:dominios; entsal X:vector[1..n]de nat) {k: numero de variables asignadas, X: asignacin actual L: valores compatibles con la asignacin actual} L2:=L i:=Seleccionar_Variable(X,L); {seleccin arbitraria} para v L[i] hacer {orden arbitrario}
X[i]:=v;
si anticipacin(X,i,v,L2) entonces si k=n entonces escribir(X) sino n-reinas(k+1,L2,X) fsi fsi L2:=L; fpara X[i]:=0; fin
N- reinas
funcion anticipacion(ent X:sol; ent i,v:entero; entsal L2:dominios) variables b:booleano; j:entero b:=cierto; j:=1; mientras (j<n+1) b hacer si X[j]=0 entonces para uL[j] hacer si u=v |i-j|=|u-v| entonces borrar(L[j],v) fpara b:=falso sino j:=j+1 fsi fmientras retorna(b)
Para n-reinas:
seleccionar la variable a la que le queden menos valores asignar los valores en orden aleatorio

Back Tracking 1193073889558994 4

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

Back Tracking 1193073889558994 4

Cargado por

Copyright:

Formatos disponibles

Bsqueda con retroceso

Bsqueda con retroceso Pg. 1

Bsqueda con retroceso: Introduccin

Problemas que consideraremos:

Bsqueda con retroceso Pg. 2

Bsqueda con retroceso: Introduccin

Planteamiento del problema:

Bsqueda con retroceso Pg. 3

Bsqueda con retroceso: Introduccin

Bsqueda con retroceso Pg. 4

Bsqueda con retroceso: Introduccin

Ejemplo: el problema de las ocho reinas

Bsqueda con retroceso Pg. 5

Bsqueda con retroceso: Introduccin

Bsqueda con retroceso Pg. 6

Bsqueda con retroceso: Introduccin

Volviendo al planteamiento general:

Bsqueda con retroceso Pg. 7

Bsqueda con retroceso: Introduccin

La llamada inicial es: ... BackTracking(1,X); ...

Bsqueda con retroceso Pg. 8

Bsqueda con retroceso: Introduccin

Bsqueda con retroceso Pg. 9

Bsqueda con retroceso: Introduccin

Bsqueda con retroceso Pg. 10

Bsqueda con retroceso: Introduccin

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

Bsqueda con retroceso Pg. 11

El problema de la suma de subconjuntos

Primera representacin de la solucin:

Bsqueda con retroceso Pg. 12

El problema de la suma de subconjuntos

Segunda representacin de la solucin:

Bsqueda con retroceso Pg. 13

El problema de la suma de subconjuntos

Bsqueda con retroceso Pg. 14

El problema de la suma de subconjuntos

x4=0 x4=0 x4=0 x4=0 x4=1 x4=1 x4=1 x4=1

Bsqueda con retroceso Pg. 15

El problema de la suma de subconjuntos

Adems la tupla (x[1],x[k]) no puede conducir a una solucin si:

Es decir, una funcin acotadora es:

Bsqueda con retroceso Pg. 16

El problema de la suma de subconjuntos

Bsqueda con retroceso Pg. 17

El problema de la suma de subconjuntos

Ntese que el algoritmo evita calcular

sin marcaje: O(n 2n)

Bsqueda con retroceso Pg. 18

El problema de la suma de subconjuntos

0,2,68 5,3,58 10,3,58

0,3,58 12,4,46 12,5,33 0,4,46 13,5,33 13,6,18 0,5,33

Bsqueda con retroceso Pg. 19

Bsqueda con retroceso Pg. 20

Un subproblema muy famoso:

El problema que consideraremos aqu:

x[2]=1 x[2]=2 x[3]=1 x[3]= 3

Bsqueda con retroceso Pg. 22

para v:=1..m hacer

Bsqueda con retroceso Pg. 23

Problema: encontrar todos los ciclos hamiltonianos de un grafo.

Bsqueda con retroceso Pg. 24

No contiene ningn hamiltoniano.

Solucin de bsqueda ... HayCamino(1,1,lab) ...

{Pre: i1..n:peso[i]>0, benef[i]>0, i1..n-1:benef[i]/peso[i]ubenef[i+1]/peso[i+1]}