05backtracking Corregido

Metodolog y Tecnolog de la Programacin a a o Curso 2009-2010 Esquemas algor tmicos.
Backtracking
Yolanda Garc Ruiz D228 a Jess Correas D228 u ygarciar@fdi.ucm.es jcorreas@fdi.ucm.es
Departamento de Sistemas Informticos y Computacin a o Universidad Complutense de Madrid (elaborado a partir de [GV00], [PS03] y notas de S. Estvez y R. e Gonzlez del Campo) a
Yolanda Garc Jess Correas (DSIC-UCM) a, u
1 / 70
Bibliograf a
Importante: Estas transparencias son un material de apoyo a las clases presenciales y no sustituyen a la bibliograf bsica ni a las a a propias clases presenciales para el estudio de la asignatura Bibliograf bsica: a a
[GV00]: cap tulo 6 [PS03]1 : cap tulo 7
Bibliograf complementaria: a
[NN98]: cap tulo 5 tulo 6 [GC01]2 : cap [BB97]: cap tulo 9 (apartado 9.6)
Ejercicios resueltos:
[MOV04]: cap tulo 14 (1) [PS03] J. I. Pelez Snchez et al. Anlisis y Diseo de algoritmos: un a a a n enfoque terico y prctico, Universidad de Mlaga, 2003 o a a (2) [GC01] D. Gimnez Cnovas Apuntes y problemas de algor e a tmica, Universidad de Murcia, 2001. Disponible en
http://servinf.dif.um.es/domingo/apuntes/Algoritmica/apuntes.pdf
Yolanda Garc Jess Correas (DSIC-UCM) a, u 2 / 70
Esquemas algor tmicos. Backtracking

1 2 3 4 5 6 7 8 9 10 11
Caracter sticas generales Esquema general de un algoritmo de backtracking Estudio de complejidad Problema de la mochila 0-1 Asignacin de tareas o El caballo de ajedrez Coloreado de mapas Las n reinas Trenes Franqueo de Postales Ciclos Hamiltonianos
3 / 70
Caracter sticas generales

Las tcnicas vistas hasta ahora intentan construir la solucin basndose en e o a ciertas propiedades de sta e Sin embargo, ciertos problemas no pueden solucionarse con ninguna de las tcnicas anteriores. e La unica manera de resolver estos problemas es a travs de un e estudio exhaustivo de un conjunto de posibles soluciones. La tcnica de backtracking permite realizar este estudio exhaustivo e Cada solucin es el resultado de una secuencia de decisiones o Pero a diferencia del mtodo voraz, las decisiones pueden deshacerse ya e sea porque no lleven a una solucin o porque se quieran explorar todas o las soluciones (para obtener la solucin ptima) o o Existe una funcin objetivo que debe ser satisfecha u optimizada por cada o seleccin o Las etapas por las que pasa el algoritmo se pueden representar mediante un a rbol de expansin (o rbol del espacio de estados). a o El rbol de expansin no se construye realmente, sino que est impl a o a cito en la ejecucin del algoritmo o Cada nivel del rbol representa una etapa de la secuencia de decisiones a
Caracter sticas generales. Ejemplo de backtracking

Se debe disear un algoritmo que permita obtener un subconjunto de n nmeros dentro del conjunto {13, 11, 7} cuya suma sea 20 u Cmo representamos la solucin? o o Tupla o vector de 3 elementos [x1 , x2 , x3 ] con xi {0, 1} Restricciones expl citas: indican qu valores pueden tomar los e componentes de la solucin o
xi = 0 indica que el elemento i no est en la solucin a o xi = 1 indica que el elemento i s est en la solucin a o
La solucin parcial debe cumplir que 3 xi datoi 20 o i=1 Restricciones impl citas: indican qu tuplas pueden dar lugar a e soluciones vlidas a La solucin debe cumplir el siguiente objetivo: o Para este problema existe una unica solucin o [1, 0, 1]
3 i=1 xi
datoi = 20
Caracter sticas generales. Ejemplo de backtracking (Cont.)

Existen dos formas de proceder: 1. Generar todas las combinaciones posibles y escoger aquellas que sean solucin o
0 1 1
2 0 1 0
9 1
3 0 1 0
6 1 0
10 1 0
13 1
11
12
14
15
Cada camino de la ra a las hojas dene una posible solucin z o 3 hojas (8 posibles soluciones) El rbol de expansin tiene 2 a o Se generan tuplas que no son soluciones ineciente
Caracter sticas generales. Ejemplo de backtracking (Cont.)

Existen dos formas de proceder: 2. Utilizar la tcnica de backtracking: a medida que se construye la e tupla, se comprueba si sta puede llegar a ser una solucin al e o problema. En caso negativo, se ignora y se vuelve al estado anterior.
0 1 1
2 0 1 0
3 0 1 0
6 1 0
10 1
11
12
7 / 70
Ejemplo de backtracking. Otra representacin de la o solucin o
Otra posible representacin de la solucin: o o Tupla o vector de a lo sumo 3 elementos ordenados con valores entre 1 y 3 (los ndices de los elementos del conjunto anterior)
1 indica que el elemento 1 (con valor 13) est en la solucin a o 2 indica que el elemento 2 (con valor 11) est en la solucin a o 3 indica que el elemento 3 (con valor 7) est en la solucin a o
Para este problema existe una unica solucin o [1, 3]
8 / 70
Ejemplo de backtracking. Otra representacin de la o solucin o

1
1 2 3
2
3
4
3
9 / 70

1 2 3 4 5 6 7 8 9 10 11
10 / 70
Esquema general de un algoritmo de backtracking

La tcnica de backtracking es un recorrido en profundidad (preorden) e del rbol de expansin a o En cada momento el algoritmo se encontrar en un cierto nivel K a En el nivel K se tiene una solucin parcial (x1 , . . . xk1 ) o Se recorren los posibles valores para el elemento xk de la solucin o
Por cada valor, se comprueba si, (x1 , . . . xk ) es prometedor se genera la solucin parcial (x1 , . . . xk ) y se avanza al nivel k + 1 o En otro caso se prueban otros valores de xk
Si ya no existen ms valores para xk , se retrocede (se a vuelve atrsbacktrack) al nivel anterior k 1 a El algoritmo contina hasta que la solucin parcial sea una solucin u o o completa del algoritmo, o hasta que no queden ms posibilidades a
11 / 70
Esquema general de backtracking recursivo

fun backtrackingRec(solucion[1..n], etapa) // valores es un vector [1..opciones] IniciarValores(valores, etapa) repetir nuevovalor SeleccionarNuevoValor(valores) si alcanzable(nuevovalor) entonces AnotarNuevoValor(solucion,nuevovalor) si SolucionIncompleta(solucion) entonces backtrackingRec(solucion, siguienteEtapa) si no si EsSolucion(solucion) entonces escribir(solucion) n si Desanotar(solucion) n si hasta UltimoValor(valores) n fun
12 / 70
Funciones que aparecen en el esquema recursivo

IniciarValores(valores) Genera todas las opciones del nivel donde se encuentra SeleccionarNuevoValor(valores) Considera un nuevo valor de los posibles Alcanzable(nuevovalor) Comprueba si la opcin nuevovalor puede forma parte de la solucion o AnotarNuevoValor(solucion,nuevovalor) Anota en solucion el valor nuevovalor EsSolucion(solucion) Indica si solucion es una solucin para el problema o Desanotar(solucion) Elimina la ultima anotacin en el vector solucion o UltimoValor(valores) Indica si ya no quedan ms nodos por expandir a
Esquema General de backtracking sin recursin o

proc backtracking(solucion[1..n]) nivel 1 n falso repetir solucion[nivel] generar (nivel, solucion) si esSolucion(solucion) entonces n cierto si no si alcanzable(nivel, solucion) entonces nivel nivel + 1 si no mientras not( hayMasHermanos(nivel, solucion)) hacer retroceder (nivel, solucion) n mientras n si hasta n = cierto n proc
Funciones que aparecen en el esquema no recursivo

generar(nivel, sol)
Dado un nivel, genera el siguiente hermano (o el primero). Devuelve el valor a aadir a la solucin parcial actual. Ejemplo: generar (1, [0, , ]) = 1 n o
esSolucion(sol)
Comprueba si la solucin calculada hasta el momento es una solucin vlida o o a para el problema. Ejemplo: esSolucion([0, 0, 1]) = falso
alcanzable(nivel, sol)
Comprueba si a partir de la solucin parcial actual es posible llegar a una o solucin vlida. Ejemplos: o a alcanzable(2, [0, 0, ]) = cierto alcanzable(2, [1, 1, ]) = falso
hayMasHermanos(nivel,sol))
Devuelve el valor cierto si el nodo actual tiene hermanos que an no han u sido generados. Ejemplo: hayMasHermanos(2, [1, 1, ]) = falso
retroceder(nivel,sol))
Retrocede un nivel en el arbol de soluciones. Disminuye en 1 el valor del nivel y actualiza la solucin actual. o
Observaciones
La representacin de las soluciones determina la forma del rbol de o a expansin o
Cantidad de descendientes de un nodo Profundidad del rbol a Cantidad de nodos del rbol a
La representacin de las soluciones determina, como consecuencia, la o eciencia del algoritmo ya que el tiempo de ejecucin depende del o nmero de nodos generados u El rbol tendr tantos niveles como valores tenga la secuencia solucin a a o En cada nodo se debe poder determinar:
Si es solucin o posible solucin del problema o o Si tiene hermanos sin generar Si a partir de este nodo se puede llegar a una solucin o
16 / 70

1 2 3 4 5 6 7 8 9 10 11
17 / 70
Estudio de complejidad
En general se obtienen rdenes de complejidad exponencial y factorial o El orden de complejidad depende del nmero de nodos generados y u del tiempo requerido para cada nodo (que podemos considerar constante) Si la solucin es de la forma (x1 , . . . , xn ), donde xi admite mi valores o En el caso peor, se generarn todas las posibles combinaciones para a cada xi Nivel 1 m1 nodos Nivel 2 m1 m2 nodos ... Nivel n m1 m2 . . . mn nodos Para el ejemplo planteado anteriormente, mi = 2 T (n) = 2 + 22 + 23 + . . . + 2n = 2n+1 2 Tiempo exponencial Cada caso depende de cmo se realice la poda del rbol, y de la o a instancia del problema
Estudio de complejidad (cont.)

Para el problema de calcular todas las permutaciones de (1, 2, . . . , n) Representamos la solucin como una tupla {x1 , x2 , . . . xn } o Restricciones expl citas: xi {i, . . . , n} En el nivel 1, tenemos n posibilidades, en el nivel 2 n 1 Nivel 1 Nivel 2 ... Nivel n Tiempo factorial T (n) = n + n (n 1) + . . . + n! O(n!) n nodos n (n 1) nodos n (n 1) . . . 1 nodos
19 / 70

1 2 3 4 5 6 7 8 9 10 11
20 / 70
Problema de la mochila 0-1
Es el mismo problema visto en programacin dinmica o a Se dispone de n objetos y una mochila de capacidad C > 0,
El peso del objeto i es wi > 0 La inclusin del objeto i en la mochila produce un benecio bi > 0 o
El objetivo consiste en llenar la mochila maximizando el valor de los objetos transportados sin sobrepasar la capacidad de la mochila Los objetos no son fraccionables
21 / 70
Problema de la mochila 0-1 (cont.)
La solucin se puede representar como una tupla {x1 , x2 , . . . xn } o Restricciones expl citas: xi (0, 1) Si xi = 0 el objeto i no se introduce en la mochila Si xi = 1 el objeto i se introduce en la mochila Restricciones impl citas:
n i=1 xi
wi C
n i=1 xi
El objetivo es maximizar la funcin o
bi
22 / 70
Cuando se encuentre una solucin, la compararemos con la mejor o solucin encontrada hasta el momento, que se ir actualizando al o a encontrar una nueva solucin con mayor benecio o Solo los nodos terminales del rbol de expansin pueden ser solucin a o o al problema La funcin alcanzable comprueba que los pesos acumulados hasta o el momento no excedan la capacidad de la mochila. Esta funcin o permite la poda de nodos
23 / 70

// elem[1..n] es un vector de estructuras con dos campos: benecio y peso proc mochila(elem[1..n],solAct[1..n],sol[1..n],benActIni,ben,pesoActIni,etapa) desde obj 0 hasta 1 hacer solAct[etapa] obj benAct benActIni + obj*elem[etapa].benecio pesoAct pesoActIni + obj*elem[etapa].peso si (pesoAct C) entonces si etapa = n entonces si benAct > ben entonces sol solAct // Se asigna el vector completo ben benAct n si si no mochila(elem,solAct,sol,benAct,ben,pesoAct,etapa+1) n si n si n desde n proc
Problema de la mochila [0,1] (cont.)

El procedimiento llamador puede ser el siguiente: proc llamador mochila(elem[1..n],sol[1..n]) crear solAct[1..n] mochila(elem,solAct,sol,0,,0,1) n proc Ejemplo: Con una mochila de capacidad C=30 y los siguientes objetos, el rbol a resultante es: objeto peso valor A 5 50 C 20 140 B 10 60
0 0 1 1
2 0 1
P=20 B=140 B 140
9 0
P=5 B=50
3 1 0
6 1 0
10 1 0
13
P=25 B=190
5
P=10 B=60
8
P=30 B=200
11
12
P=15 B=110
14
P=25 P 25 B=190
25 / 70

1 2 3 4 5 6 7 8 9 10 11
26 / 70
Asignacin de tareas o
(Basado en [GV00], p. 229.) Disponemos de n empleados y n tareas a realizar Mediante una tabla M de tamao n n, representamos con M[i, j] el n coste de realizar la tarea j por el empleado i, para i, j = 1, . . . , n El problema consiste en asignar a cada operario i una tarea j de forma que se minimice el coste total. La solucin se puede representar como una tupla Sol = x1 , x2 , . . . xn o Restricciones expl citas: xi {1, . . . n} xi es la tarea asignada al i-simo empleado e Restricciones impl citas: xi = xj , i = j El objetivo es minimizar la funcin n M[i, xi ] o i=1 Por cada solucin que encuentre el algoritmo, se anotar su coste y se o a comparar con el coste de la mejor solucin encontrada hasta el a o momento
Asignacin de tareas (Cont.) o

proc Tareas(M[1..n,1..n],XAct[1..n],mejorX[1...n],costeAcIni,coste,etapa) XAct[etapa] 0 repetir XAct[etapa] XAct[etapa] + 1 si TareaNoAsignada(XAct,etapa) entonces costeAc costeAcIni + M[etapa,XAct[etapa]] si (costeAc coste) entonces si etapa < n entonces tareas(M,XAct,mejorX,costeAc,coste,etapa+1) si no mejorX XAct coste costeAc n si n si n si hasta XAct[etapa]=n n proc
El cdigo de TareaNoAsignada es el siguiente: o fun TareaNoAsignada(Asignadas, n) desde i 1 hasta n-1 hacer si Asignadas[i] = Asignadas[n] entonces devolver falso n si n desde devolver cierto n fun
29 / 70

El procedimiento llamador es:
proc llamador tareas(M[1..n,1..n],X[1..n],C) crear XAct[1..n] C Tareas(M,XAct,X,0,C,1) n proc
Este algoritmo realiza podas en el rbol de expansin eliminando aquellos a o nodos que no van a llevar a la solucin ptima o o
1 T1 C=3 2 T2 C=13 C= 13 T3 C=4 5 T2 C=9 4 6 8 T T2 C=5 7 T3 C=6 T3 C 1 C=1 9
3 T3 3 C=18
3 5 1 10 10 1 8 5 5
30 / 70

3 5 1 10 10 1 8 5 5 La secuencia de llamadas para la matriz de Tareas tareas([0,0,0], [0,0,0], 0, , 1) tareas([1,0,0], [0,0,0], 3, , 2) tareas([1,2,0], [0,0,0], 13, , 3) mejorX=[1,2,3] tareas([1,3,0], [1,2,3], 4, 18, 3) mejorX=[1,3,2] tareas([2,0,0], [1,3,2], 5, 9, 2) tareas([2,3,0], [1,3,2], 6, 9, 3) tareas([3,0,0], [1,3,2], 1, 9, 2)
31 / 70

1 2 3 4 5 6 7 8 9 10 11
32 / 70
El caballo de ajedrez
Consideremos un caballo de ajedrez colocado en una posicin, X , Y o de un tablero de dimensiones n n. Se trata de encontrar una sucesin de movimientos vlidos de un caballo de ajedrez de forma o a que ste pueda visitar todas y cada una de las casillas del tablero sin e repetir ninguna El algoritmo voraz no encontraba solucin para un tablero con n = 5 o y partiendo de la posicin inicial (x, y ) = (5, 3) o
33 / 70
El caballo de ajedrez (Cont.)

La solucin la representamos como una matriz de enteros de dos o dimensiones Sol[1..n, 1..n]
Inicialmente Sol[i, j] = 0 la casilla (i, j) no ha sido visitada Sol[i, j] = k signica que el caballo ha pasado por la casilla (i, j) en la etapa k
Los movimientos que puede hacer el caballo se representan mediante vectores constantes
6 5 4 3 2 7 8 1
dx = [ dy = [
2 1
1 2
-1 2
-2 1
-2 -1
-1 -2
1 -2
2 -1
] ]
34 / 70

Esquema de alto nivel del algoritmo:
proc saltoCaballo repetir seleccionar un movimiento m vlido del caballo (solo hay 8) a si (m est en el tablero) (la casilla no est repetida) entonces a a anotar movimiento si numeroSaltos < n n entonces seguir moviendo si no alcanzado solucin entonces o deshacer anotacin anterior o n si n si n si hasta (visitado las n n casillas) or (agotados los 8 movimientos) n proc
35 / 70

Para denir el algoritmo detallado, tenemos las siguientes consideraciones
Los vectores dx y dy son constantes globales. La solucin se representa con la matriz sol o Las variables posXini y posYini representan la posicin de partida del o caballo en el tablero La variable exito devuelve cierto si despus de un movimiento se puede e encontrar una solucin o El programa llamador podr ser algo como a fun llamador caballo(sol[1..n,1..n],posXini,posYini) inicializar(sol, dx, dy) sol[posXini, posYini] 1 exito falso saltoCaballo(sol, 2, posXini, posYini, exito) devolver exito n fun

proc saltoCaballo(sol[1..n, 1..n], etapa, posX , posY , exito) k 0 // indica el nmero de movimientos del caballo(8) u repetir k k +1 Nx posX + dx[k] Ny posY + dy [k] si ((1 Nx n) (1 Ny n)) entonces si sol[Nx, Ny ] = 0 entonces sol[Nx, Ny ] etapa si etapa < n n entonces saltoCaballo(sol, etapa + 1, Nx, Ny , exito) si exito entonces sol[Nx, Ny ] 0 si no exito cierto n si n si n si hasta (exito k =8) n proc

1 2 3 4 5 6 7 8 9 10 11
38 / 70
Coloreado de mapas
[GV00], p. 246. Dado un grafo conexo no dirigido y un numero m > 0, llamamos colorear el grafo a asignar un numero i (1 i m) a cada vrtice, de e forma que dos vertices adyacentes nunca tengan asignados numeros iguales Supongamos que el grafo tiene n vrtices e Deseamos implementar un algoritmo que coloree un grafo dado Este problema proviene de un problema clsico de coloreado de mapas a en el plano. Dado un mapa, Cul es el m a nimo nmero de colores u necesario para colorear sus regiones de forma que no haya dos regiones adyacentes de igual color?
Cada regin se corresponde con un nodo o Si dos regiones son adyacentes, sus nodos se conectan con un arco As siempre se obtiene un grafo donde sus arcos nunca se cruzan , (grafo planar)
Coloreado de mapas (Cont.)

1
11111
2
4 2
3
3
3 1 4 5
Se puede demostrar que 4 colores siempre son sucientes para colorear un mapa.
La solucin se puede representar como una tupla x1 , x2 , . . . xn donde o xi es el color del vrtice i e Si se dispone de m colores, en la etapa k el algoritmo asigna un color c {1, . . . m} al vrtice k. e Restricciones expl citas: xi {1, . . . , m} Restricciones impl citas: Vrtices adyacentes no pueden ser del mismo e color El objetivo es buscar una forma de colorear el grafo utilizando solo m colores
41 / 70

// grafo es una matriz de tipo booleano // sol es un vector de enteros (contiene numeros de color, 1..m) fun colorearMapa(grafo[1..n, 1..n], sol[1..n], m, etapa) sol[etapa] 0 ; exito falso repetir sol[etapa] sol[etapa] + 1 si aceptable(grafo, sol, etapa) entonces si etapa < n entonces exito colorearMapa(grafo, sol, m, etapa + 1) si no exito cierto n si n si hasta exito sol[etapa]= m devolver exito n fun
El programa llamador podr ser el siguiente a

fun llamador mapa(grafo[1..n,1..n],m,sol[1..n]) desde i 1 hasta n hacer sol[i] 0 n desde devolver colorearMapa(grafo,sol,m,1) n fun
43 / 70

La funcin aceptable comprueba que dos vrtices adyacentes no o e tengan el mismo color fun aceptable(grafo[1..n,1..n],sol[1..n],etapa) desde j 1 hasta etapa-1 hacer si grafo[etapa,j] sol[etapa]=sol[j] entonces devolver falso n si n desde devolver cierto n fun
44 / 70

Supongamos ahora que lo que deseamos es obtener todas las formas distintas de colorear un grafo
proc colorearMapaTodasSoluciones(grafo[1..n,1..n],sol[1..n],m,etapa) sol[etapa] 0 repetir sol[etapa] sol[etapa]+1 si aceptable(grafo,sol,etapa) entonces si etapa < n entonces colorearMapaTodasSoluciones(grafo,sol,m,etapa+1) si no comunicar(sol) n si n si hasta sol[etapa]= m // hasta el ultimo color n proc
45 / 70

Supongamos ahora que lo que deseamos es colorear un grafo con el m nimo nmero de colores u
proc colorearMapaOptimizado(grafo[1..n,1..n],sol[1..n],m,etapa) sol[etapa] 0 repetir sol[etapa] sol[etapa]+1 si aceptable(grafo,sol,etapa) entonces si etapa < n entonces colorearMapaOptimizado(grafo,sol,m,etapa+1) si no numcol numColoresEn(sol,m) si minimo > numcol entonces mejorSol sol ; minimo numcol n si n si hasta sol[etapa]= m // hasta el ultimo color n proc
Las variables mejorSol y minimo son globales. Cmo ser el programa o a llamador en este caso? Cmo ser sin variables globales? o a

La funcin numColoresEn calcula el nmero de colores diferentes o u utilizados en una solucin o
// m es el numero de colores fun numColoresEn(sol,m) contador 0 desde j 1 hasta m hacer i1 continuar cierto mientras (i n) and (continuar) hacer si sol[i]= j entonces contador contador+1 continuar falso n si i i+1 n mientras n desde devolver contador n fun

1 2 3 4 5 6 7 8 9 10 11
48 / 70
Las n reinas
[GV00], p. 212. Es otro problema clsico de computacin a o Consiste en encontrar la forma de disponer n reinas en un tablero de ajedrez n n de forma que no se amenacen entre ellas Los movimientos que puede realizar una reina de ajedrez son:
49 / 70
Las n reinas (cont.)

En este caso, por los movimientos que se pueden realizar, no es posible que una solucin del problema tenga dos reinas en la misma o la o columna Por ello, si debemos colocar n reinas en un tablero n n, cada la y cada columna tendrn una sola reina a En lugar de representar la solucin mediante una matriz n n, o podemos utilizar un vector de tamao n, X[1..n], en el que X[i] n representa la columna en la que est situada la reina i-sima (que a e estar en la la i-sima) a e Las restricciones de este problema son las siguientes:
restricciones expl citas: los elementos del vector solucin solamente o pueden tener valores entre 1 y n (columnas). La restriccin sobre las o las est determinada por la propia estructura de la solucin (al ser un a o vector X[1..n]) restricciones impl citas: no puede haber dos reinas en la misma columna ni en la misma diagonal.
Las n reinas (cont.)

fun reinas(k,sol[1..n]) exito falso sol[k] 0 repetir sol[k] sol[k] + 1 si valido(sol,k) entonces si k = n entonces exito reinas(sol,k+1) si no exito cierto n si n si hasta (sol[k] = n) exito devolver exito n fun
fun valido(sol[1..n],k) desde i 1 hasta k-1 hacer si sol[i]=sol[k] |sol[i]-sol[k]| = |i-k| entonces devolver falso n si n desde devolver cierto n fun Llamada inicial: reinas(1,sol)
51 / 70

1 2 3 4 5 6 7 8 9 10 11
52 / 70
Trenes
(basado en [GV00], p. 242). Sea una regin con n ciudades. Se pretende ir de una ciudad a otra de o la misma regin o Para ello disponemos de los horarios de todos los trenes que comunican las ciudades de esa regin o Se conoce tambin la duracin de cada viaje e o Se supone que, a lo sumo, hay un tren para cada par de ciudades El objetivo es encontrar un camino para viajar entre dos ciudades dadas, de forma que se minimice el tiempo empleado.
53 / 70
Trenes (Cont.)
Supongamos que las ciudades estn numeradas de 1 a n. a Los horarios y duraciones de viaje de los trenes se representan en una matriz de horarios H[1..n, 1..n] en la que cada elemento tiene dos atributos, duracion y hora. Los elementos de esta matriz tienen en ambos atributos si las ciudades i y j no estn comunicadas. a Representamos la solucin del problema mediante una tupla o Sol = x1 , x2 , . . . xk La tupla solucin solo tiene valores hasta el nivel k, siendo k el o nmero de ciudades por las que tenemos que pasar (k n) u Tiene que cumplirse
x1 es la ciudad de origen xk es la ciudad de destino xi est comunicada con la ciudad xi+1 para 1 i (k 1) a
Trenes (Cont.)
// H es una matriz de estructuras con dos atributos: duracion y hora (de salida). proc trenes(H[1..n,1..n],solAct[1..n],sol[1..n],dest,etapa,hora,durAcIni,durMinimo) j 0 // j representa la ciudad repetir j j + 1 ; solAct[etapa] j si aceptable(H,solAct,hora,etapa) entonces duracionEspera H[solAct[etapa-1], j].hora - hora duracionAc durAcIni + duracionEspera + H[solAct[etapa-1], j].duracion si j = dest entonces si duracionAc < durMinimo entonces sol solAct ; durMinimo duracionAc n si si no si etapa < n entonces horallegada H[solAct[etapa-1], j].hora+ H[solAct[etapa-1], j].duracion trenes(H,solAct,sol,dest,etapa+1, horallegada, duracionAc,durMinimo) n si n si hasta j = n solAct[etapa] 0 //no deja basura en la solucin o n proc
Trenes (Cont.)
Los argumentos sol y durMinimo contienen la solucin ptima: el o o recorrido ptimo y el tiempo total del trayecto. Se podr denir o an como variables globales El argumento durAcIni en la etapa k almacena el tiempo empleado en recorrer el camino entre las ciudades origen y sol[k-1]: la suma de los tiempos de espera entre los diferentes trenes y las duraciones de los trayectos hasta k 1. Se supone en este problema que todos los recorridos tienen lugar en el mismo d Si no fuera as deber tenerse en cuenta que en algunos a. , a casos es necesario esperar al d siguiente para continuar el recorrido a
56 / 70
Trenes (Cont.)
El programa llamador podr ser el siguiente a proc llamador trenes(H[1..n,1..n],origen,dest,sol[1..n],duracion) crear solAct[1..n] duracion hora 00:00 solAct[1] origen trenes(H,solAct,sol,dest,2,hora, 0,duracion) n proc Si el problema no tiene solucin, al nal de la ejecucin la variable o o duracion contendr . a
57 / 70
Trenes (Cont.)
La funcin aceptable comprueba o
que toda ciudad debe estar comunicada con la anterior que la hora de llegada a la ciudad de la etapa anterior sea menor que la hora de salida del tren a la ciudad j que no se pase dos veces por la misma ciudad fun aceptable(H,sol,hora,etapa) si (H[sol[etapa-1], sol[etapa]].hora < ) (hora <H[sol[etapa-1], sol[etapa]].hora) entonces desde i 1 hasta etapa-1 hacer si sol[i]= sol[etapa] entonces devolver falso n si n desde devolver cierto si no devolver falso n si n fun

1 2 3 4 5 6 7 8 9 10 11
59 / 70
Franqueo de postales
Consideremos una postal en la que se pueden poner un mximo de M a sellos Se dispone de un nmero limitado de unidades de cada tipo de sellos u Para poder enviar la postal, se necesita franquearla con una tarifa m nima Adems, se supone que el orden de los sellos en la postal debe ser tal a que su valor sea decreciente Determinar la forma de franquear la postal de forma que el coste sea m nimo
60 / 70
Franqueo de postales (Cont.)

La informacin de los tipos de sellos se proporciona mediante un o vector S[1..N] con dos atributos:
valor: valor de cada tipo de sello cantidad: nmero de unidades de cada tipo u
El vector S debe contener los tipos de sello ordenados en orden decreciente de valor Representamos la solucin del problema mediante una tupla o Sol = x1 , x2 , . . . xk , k m, donde xi indica el tipo de sello en la posicin i de la postal o Debe cumplirse la restriccin expl o cita xi {1..N} y la restriccin impl o cita siguiente: el valor del sello xi debe ser mayor o igual que el valor del sello xi+1 para 1 < i < M 1 y xi = 0
61 / 70

// S es un vector de estructuras con dos atributos: cantidad y valor. proc franqueo(S[1..N],tarifa,etapa,tipoSello,solAct[1..M],costeAcIni,sol[1..M],coste) si etapa M entonces desde j tipoSello hasta N hacer si (S[j].cantidad>0) entonces solAct[etapa] j costeAc costeAcIni + S[j].valor S[j].cantidad S[j].cantidad - 1 si (costeAc tarifa) entonces si (costeAc < coste) entonces coste costeAc ; sol solAct si no franqueo(S,tarifa,etapa+1,j,solAct,costeAc,sol,coste) n si S[j].cantidad S[j].cantidad + 1 // Deshace anotacin de S[j].cantidad o n si n desde solAct[etapa] 0 //no deja basura en la solucin o n si n proc

El programa llamador podr ser a proc llamador franqueo(S,tarifa,sol[1..M],coste) crear solAct[1..M] desde i 1 hasta n hacer solAct[i] 0 // inicialmente no hay sellos n desde coste franqueo(S,tarifa,1,1,solAct,0,sol,coste) n proc Si el problema no tiene solucin, al nal de la ejecucin la variable o o coste contendr . a
63 / 70

1 2 3 4 5 6 7 8 9 10 11
64 / 70
Ciclos Hamiltonianos
Sea g un grafo no dirigido con n vrtices e Llamamos ciclo hamiltoniano a un camino que visita una sola vez todos los vrtices y vuelve al vrtice inicial e e
1 5 2 B A E
4 3
123451 123541 154321 145321
Ningn hamiltoniano u
El objetivo es encontrar todos los ciclos hamiltonianos de un grafo Existen algoritmos voraces muy ecientes para este tipo de problemas, pero pueden no proporcionar la solucin ptima o o
Ciclos Hamiltonianos (Cont.)

Utilizaremos la representacin del grafo mediante una matriz de o adyacencia G [1..n, 1..n] binaria Representamos la solucin del problema mediante una tupla o sol = x1 , x2 , . . . xn donde xi indica el vrtice visitado en el isimo e e lugar en el ciclo Para evitar repetir varias veces el mismo ciclo, partimos siempre del vrtice 1 (por ejemplo), es decir, x1 = 1 e Han de cumplirse las siguientes restricciones
xi = xj para i, j {1, . . . , n}, i = j Los vrtices xi y xi+1 han de estar conectados para i {1, . . . , n 1} , e es decir, G [xi , xi+1 ] = cierto El vrtice xn ha de estar conectado con el vrtice x1 y con el xn1 e e
66 / 70
proc hamiltoniano(G[1..n,1..n],etapa,sol[1..n]) repetir siguienteVertice(G,sol,etapa) // asigna a sol[etapa] el siguiente vertice si sol[etapa] = 0 entonces si etapa = n entonces comunicar(sol) si no hamiltoniano(G,etapa+1,sol) n si n si hasta sol[etapa] = 0 n proc
67 / 70

siguienteVertice busca un vrtice v vlido para la etapa k e a partiendo de una solucin parcial de k 1 vrtices o e
v est conectado con el vrtice de la etapa anterior: a e G [sol[k 1], v ] = cierto v no aparece en la solucin parcial de k-1 vrtices: sol[i] = v para o e 1i k 1 Si estamos en la ultima etapa (k = n), debemos exigir que v est conectado con el primer vrtice. e e
siguienteVertice puede ser llamado varias veces para una misma etapa, seleccionando en cada llamada el siguiente vrtice que e cumple las restricciones Si no encontramos ningn vrtice (ms) que verique las restricciones, u e a entonces siguienteVertice asigna el valor 0 a sol[k]
68 / 70

proc siguienteVertice(G[1..n,1..n],sol[1..n], etapa) // sol[etapa] contiene el ultimo valor asignado, o 0 si no se ha asignado ninguno repetir sol[etapa] sol[etapa]+1 si sol[etapa] n entonces encontrado falso si G[sol[etapa-1],sol[etapa]] entonces j 1, encontrado cierto mientras j etapa-1 encontrado hacer si sol[j] = sol[etapa] entonces encontrado falso si no j j+1 n mientras si encontrado etapa=n G[sol[n],1] entonces encontrado falso n si n si n si hasta sol[etapa] > n encontrado si sol[etapa] > n entonces sol[etapa] 0 n proc
El programa llamador ser a proc llamador hamiltoniano(G[1..n,1..n]) crear sol[1..n] desde i 2 hasta n hacer sol[i] 0 n desde sol[1] 1 hamiltoniano(G,2,sol) n proc
70 / 70

05backtracking Corregido

Hochgeladen von

Dokumentinformationen

Originaltitel

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

05backtracking Corregido

Hochgeladen von

Copyright:

Verfügbare Formate

Metodolog y Tecnolog de la Programacin a a o Curso 2009-2010 Esquemas algor tmicos.

Yolanda Garc Jess Correas (DSIC-UCM) a, u

Esquemas algor tmicos. Backtracking

Yolanda Garc Jess Correas (DSIC-UCM) a, u

Caracter sticas generales

Caracter sticas generales. Ejemplo de backtracking

Caracter sticas generales. Ejemplo de backtracking (Cont.)

Caracter sticas generales. Ejemplo de backtracking (Cont.)

Yolanda Garc Jess Correas (DSIC-UCM) a, u

Ejemplo de backtracking. Otra representacin de la o solucin o

Para este problema existe una unica solucin o [1, 3]

Yolanda Garc Jess Correas (DSIC-UCM) a, u

Ejemplo de backtracking. Otra representacin de la o solucin o

Yolanda Garc Jess Correas (DSIC-UCM) a, u

Esquemas algor tmicos. Backtracking

Yolanda Garc Jess Correas (DSIC-UCM) a, u

Esquema general de un algoritmo de backtracking

Yolanda Garc Jess Correas (DSIC-UCM) a, u

Esquema general de backtracking recursivo

Yolanda Garc Jess Correas (DSIC-UCM) a, u

Funciones que aparecen en el esquema recursivo

Esquema General de backtracking sin recursin o

Funciones que aparecen en el esquema no recursivo

Yolanda Garc Jess Correas (DSIC-UCM) a, u

Esquemas algor tmicos. Backtracking

Yolanda Garc Jess Correas (DSIC-UCM) a, u

Estudio de complejidad (cont.)

Yolanda Garc Jess Correas (DSIC-UCM) a, u

Esquemas algor tmicos. Backtracking

Yolanda Garc Jess Correas (DSIC-UCM) a, u

Problema de la mochila 0-1

Yolanda Garc Jess Correas (DSIC-UCM) a, u

Problema de la mochila 0-1 (cont.)

El objetivo es maximizar la funcin o

Yolanda Garc Jess Correas (DSIC-UCM) a, u

Problema de la mochila 0-1 (cont.)

Yolanda Garc Jess Correas (DSIC-UCM) a, u

Problema de la mochila 0-1 (cont.)

Problema de la mochila [0,1] (cont.)

Yolanda Garc Jess Correas (DSIC-UCM) a, u

Esquemas algor tmicos. Backtracking

Yolanda Garc Jess Correas (DSIC-UCM) a, u

Asignacin de tareas (Cont.) o

Asignacin de tareas (Cont.) o

Yolanda Garc Jess Correas (DSIC-UCM) a, u

Asignacin de tareas (Cont.) o

Yolanda Garc Jess Correas (DSIC-UCM) a, u

Asignacin de tareas (Cont.) o

Yolanda Garc Jess Correas (DSIC-UCM) a, u

Esquemas algor tmicos. Backtracking

Yolanda Garc Jess Correas (DSIC-UCM) a, u

Yolanda Garc Jess Correas (DSIC-UCM) a, u

El caballo de ajedrez (Cont.)

Yolanda Garc Jess Correas (DSIC-UCM) a, u

El caballo de ajedrez (Cont.)

Yolanda Garc Jess Correas (DSIC-UCM) a, u

El caballo de ajedrez (Cont.)

El caballo de ajedrez (Cont.)

Esquemas algor tmicos. Backtracking

Yolanda Garc Jess Correas (DSIC-UCM) a, u

Coloreado de mapas (Cont.)

Coloreado de mapas (Cont.)

Yolanda Garc Jess Correas (DSIC-UCM) a, u