rboles y esquemas algortmicos

Tema III

Esquemas Algortmicos

(Lecciones 21 y 22 )

Esquemas Algortmicos
Tcnicas de carcter general que pueden utilizarse
para resolver grandes clases o familias de problemas
Clasificacin habitual:

Divide y vencers (Divide and Conquer) Vuelta atrs o retroceso (Backtracking ) Mtodos voraces (Greedy techniques) Programacin dinmica (Dynamic Programming) Ramificacin y poda (Branch and Bound) .

Bibliografa
Tema III (lecciones 21 y 22) del libro Campos Laclaustra, J.:
Estructuras de Datos y Algoritmos, Prensas Universitarias de Zaragoza, Coleccin Textos Docentes, 1995 N. Mart, Y. Ortega y J.A. Verdejo; Estructuras de Datos y Mtodos Algortmicos. Ejercicios Resueltos. Pearson Prentice Hall, 2003. Captulos 11, 14, 12, 15 y 13 . Joyanes, L., Zahonero, I., Fernndez, M. y Snchez, L.: Estructuras de datos. Libro de problemas, McGraw Hill, 1999., captulo 3 (recursin)

Libro Algoritmos y estructuras de datos de N. Wirth ( algunas

pginas disponibles en la Web de EDA).

G. Brassard, P. Bratley; Algortmica. Concepcin y Anlisis.

Editorial. Editorial Masson, 1 Edicin 1990

Y muchos otros....

Esquema Divide y Vencers

Esquema (o tcnica) de diseo de algoritmos
divide y vencers (Divide and Conquer): Tcnica basada en:
Descomponer el problema a resolver en un cierto
nmero de subproblemas, ms pequeos pero del mismo tipo que el problema original; resolver independientemente cada subproblema; combinar los resultados obtenidos para construir la solucin del problema original. aplicar estos pasos recursivamente Este esquema se expresa de forma natural mediante recursin

Esquema Divide y Vencers

Esquema genrico:
funcin divide_y_vencers (x:tx) devuelve ty variables x1, ,xk: tx; y1,,yk: ty principio si x es suficientemente simple entonces
{se puede resolver sin dividir ms}

devuelve solucin_simple(x) sino descomponer x en x1, ,xk; para i:=1 hasta k hacer yi:=divide_y_vencers(xi) fpara; devuelve combinar(y1,,yk) fsi Fin

Si k=1, el esquema anterior se llama tcnica de reduccin.

Esquema Divide y Vencers

Para que merezca la pena aplicar este mtodo, se
debe cumplir que:
Las operaciones de combinar y descomponer deben ser lo
suficientemente eficientes El nmero de subproblemas generados sea pequeo Los subproblemas deben ser aproximadamente del mismo tamao y no solaparse entre si La profundidad de llamadas recursivas debe estar acotada en un lmite razonable

Backtracking
Existen problemas para los que no parece haber una
forma, teora o regla fija de clculo, que nos lleve a obtener la solucin buscada, y lo nico que se puede hacer es recurrir a una bsqueda exhaustiva para identifica la o las soluciones vlidas entre el conjunto de todas las posibles (prueba y error, o tanteo sistemtico)
fuerza bruta: realizar una bsqueda exhaustiva por el espacio
de posibles soluciones, hasta encontrar la/las soluciones que satisfagan las condiciones exigidas, o comprobar que no existe tal solucin Impracticable, si el cardinal del conjunto de soluciones posibles crece de forma exponencial o es de tamao muy grande (situacin habitual) Es necesario estructurar el espacio de soluciones a explorar, intentando descartar cuanto antes grandes bloques de soluciones no vlidas

Backtracking

Ejemplo : El problema de las 8 reinas

Colocar 8 reinas en un tablero de ajedrez sin
que se den jaque

Dos reinas se dan jaque, o amenazan, si comparten fila, columna o diagonal Fuerza bruta:
Tamao del espacio de soluciones
64 8 = 4.426.165.368

Backtracking
Un esquema muy til de prueba y error es el
denominado backtracking (bsqueda con retroceso, o vuelta atrs)
Mtodo de resolucin de problemas basado en el tanteo
sistemtico y exhaustivo, en el cual la solucin del problema se divide en pasos Las posibles soluciones se forman de manera progresiva (solucin parcial), comprobando en cada paso o etapa si la solucin que se est construyendo puede llevar o no a una solucin satisfactoria

Diferencia entre la fuerza bruta y la bsqueda con

retroceso:
Si se comprueba que la solucin parcial que se est
construyendo no puede conducir a ninguna solucin vlida, se evita evaluar las soluciones que se construiran a partir de ella

La tcnica de backtracking se puede emplear con el

objetivo de encontrar una solucin, todas las soluciones posibles, o la solucin ptima, al problema planteado

Backtracking

Ejemplo : El problema de las 8 reinas

Colocar 8 reinas en un tablero de ajedrez sin
que se den jaque

Dos reinas se dan jaque, o amenazan, si comparten fila, columna o diagonal 64 Fuerza bruta: = 4.426.165.368
Tamao del espacio de soluciones
8

Replanteamiento: colocar una reina en cada fila del tablero, de forma que no se den jaque Toda solucin del problema se puede representar como
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

Backtracking
Se consideran problemas cuyas soluciones son construibles por
etapas o subtareas, de forma que cada una de ellas admita varias soluciones o decisiones: Una solucin ser expresable en forma de tupla (X1, ., Xn), donde cada XiSi representa la decisin tomada en la etapa isima, de entre un conjunto finito de alternativas (Si). La solucin buscada deber minimizar, maximizar o satisfacer cierta funcin criterio o funcin objetivo (condiciones a cumplir para ser una solucin satisfactoria o vlida) Existirn predicador acotadores o funciones objetivo parciales: Pi (x1, ., xi), que indiquen si (x1, ., xi) puede conducir a una solucin Existirn dos categoras de restricciones: Restricciones explcitas: indican los conjuntos Si , es decir, el conjunto finito de alternativas entre las cuales puede tomar valor cada una de las componentes de la tupla solucin Restricciones implcitas: sern las relaciones que se han de establecer entre las componentes de la tupla solucin (decisiones tomadas en cada etapa) para satisfacer la funcin objetivo (llevar a obtener una solucin vlida)

Backtracking

Ejemplo : El problema de las 8 reinas

Restricciones explcitas:

Si={1,2,3,4,5,6,7,8}, 1i 8 Por lo tanto el espacio de soluciones consta de 88 8tuplas (16.777.216 8-tuplas)

Restricciones implcitas:

no puede haber dos reinas en la misma columna ni en la misma diagonal 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 a 8! 8-tuplas( 40.320)

Backtracking
El espacio de soluciones estar formado por el conjunto de
tuplas que satisfacen las restricciones explcitas, y se puede estructurar como un rbol de exploracin, donde en cada nivel se toma la decisin de la etapa (subtarea) correspondiente Cada nivel se corresponde con resolver una subtarea
tomando una decisin de entre el conjunto de las posibles La construccin de una candidata a solucin completa del problema inicial, se obtienen siguiendo un camino en el rbol, que empieza en la raz y va descendiendo hasta llegar a una hoja Si en un momento dado se descubre que una candidata no es solucin, o no puede llevar a ninguna solucin, se retrocede al nivel anterior y se ensaya otra decisin o solucin para la subtarea

Backtracking
Ejemplo : rbol de exploracin del espacio de soluciones
para el problema de las 4 reinas (tablero de 4x4) El espacio de soluciones est definido por todos los caminos
desde la raz a cada hoja (4! Hojas)

Backtracking
Denominacin: Se denomina nodo estado a cualquier nodo del rbol de
exploracin, correspondiente a una tupla (solucin) parcial o completa, y satisfaciendo las restricciones explcitas Los nodos solucin sern los correspondientes a tuplas completas que satisfagan las restricciones implcitas

Para que el rbol de exploracin crezca de forma

razonable y la tcnica sea aplicable, se emplean Predicados acotadores (funciones de poda o tests de factibilidad) obtenidos a partir de la funcin objetivo, permiten determinar
cuando una tupla parcial no podr conducir a soluciones satisfactorias se evitar seguir buscando a partir de ella (el rbol no crecer por su rama)

Backtracking
El rbol no se construye de forma explcita, sino que
est implcito en el algoritmo (en las llamadas recursivas del algoritmo de bsqueda) Durante el proceso, para cada nodo (estado en una
etapa) se irn generando sus sucesores (estados alcanzables tomando la decisin correspondiente a la siguiente etapa)
Nodos vivos: aquellos para los cuales no se han generado todos
sus hijos Nodos en expansin: aquellos para los cuales se estn generando hijos Nodos muertos: aquellos que o bien no han superado el test de factibilidad (se ha comprobado que no podrn llevar a soluciones vlidas) o bien todos sus hijos ya han sido evaluados

Cuando se llega a un nodo muerto, hay que deshacer la

ltima decisin tomada (retroceso o vuelta atrs), y optar por otra alternativa
La forma ms sencilla de expresar ese retroceso es mediante un
algoritmo recursivo (la vuelta atrs se consigue automticamente resolviendo la llamada recursiva y volviendo a aquella que la invoc)

Backtracking
Esquema general:
algoritmo ensaya Principio inicializar seleccin de candidatos; repetir seleccionar siguiente; si aceptable entonces {evaluar predicados acotadores} registrarlo; si solucin incompleta entonces ensaya; {devolver booleano indicando xito o no} si no exitoso entonces cancelar registro fsi fsi Fsi {salir si se ha encontrado solucin o agotado la bsqueda} hastaQue exitosa or no ms candidatos fin

Backtracking
Esquema con parmetro explcito de nivel (i), n de niveles
conocido (n) y n fijo de candidatos por investigar (m): algoritmo ensaya(ent i:entero) variable k:entero principio k:=0; repetir k:=k+1; seleccionar k-simo candidato; si aceptable entonces registrarlo; si i<n entonces ensaya(i+1); si no exitoso entonces cancelar registro fsi fsi fsi {salir si se ha encontrado solucin o agotado la bsqueda} hastaQue exitoso or (k=m) fin

Backtracking
Una vez definido el rbol de exploracin del espacio
de soluciones, el algoritmo para resolver el problema se basa en realizar un recorrido por el rbol en cierto orden, sin entrar en zonas podadas, hasta:
Encontrar la primera solucin, o Encontrar y devolver todas las soluciones vlidas, o Evaluar todas las soluciones vlidas y devolver la ptima

Backtracking
Lo mismo que el anterior, para el clculo de TODAS las soluciones:
algoritmo ensaya(ent i:entero) variable k:entero principio para k:=1 hasta m hacer seleccionar k-simo candidato; si aceptable entonces registrarlo; si i<n entonces ensaya(i+1) sino escribir solucin fsi; cancelar registro fsi fpara fin

Backtracking
Una vez definido el rbol de exploracin del espacio
de soluciones, el algoritmo para resolver el problema se basa en realizar un recorrido por el rbol en cierto orden, sin entrar en zonas podadas, hasta:
Encontrar la primera solucin, o Encontrar y devolver todas las soluciones vlidas, o Evaluar todas las soluciones vlidas y devolver la ptima Requiere recordar la mejor solucin de todas las encontradas
hasta el momento Se puede mejorar la eficiencia de la bsqueda si los predicados acotadores permiten eliminar nodos de los que se sepa que no pueden llevar a una solucin mejor que la actualmente disponible (poda; mtodos de ramificacin y poda)

Backtracking
En el esquema de backtracking, el rbol de exploracin se
recorre en profundidad y con predicados acotadores: Dada una etapa, se toma una decisin y se genera su nodo, y
se continua expandindolo y explorando todas las posibilidades generables a partir de el, antes de considerar otra de las decisiones alternativas para dicha etapa El algoritmo no hace llamadas recursivas cuando se han tomado decisiones para todas las etapas de proceso de solucin, o bien cuando ningn nodo generado satisface los predicados acotadores

En el esquema de Ramificacin y Poda, en cada etapa se

selecciona, para expandir y explorar, el nodo vivo ms prometedor Para la aplicabilidad de estas tcnicas es crucial que las funciones de poda (predicados acotadores) permitan identificar y descartar grandes porciones del espacio de soluciones, pero sin llegar a ser demasiado sofisticadas y costosas

Backtracking
Problema: colocar n reinas en un tablero de dimensiones nxn,
sin que se den jaque 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 filacolumna. ( f1 - c1 = f 2 - c2) ( f 1 + c1 = f 2 + c2) (c1 - c2 = f 1 - f 2) (c1 - c2 = f 2 - f 1) c1 - c2 = f 1 - f 2

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

Backtracking
Problema: colocar n reinas en un tablero de dimensiones
nxn, sin que se den jaque VERSIN RECURSIVA:
algoritmo colocarReinas(ent k:entero; entsal sol: vector[1..n]de entero) {Pre: sol[1..k-1] estn bien colocadas} variables i:entero principio para i:=1 hasta n hacer sol[k]:=i; si buenSitio(k,sol) entonces si k=n entonces escribir(sol) sino colocarReinas(k+1,sol) fsi fsi fpara fin

Llamada inicial: colocarReinas(1,sol);.

 Problema: colocar n reinas en un tablero de dimensiones nxn,

sin que se den jaque VERSIN ITERATIVA:
algoritmo nReinas(ent n:entero) variables k:entero; x:vector[1..n]de entero principio x[1]:=0; k:=1; mq k>0 hacer {para frenar el ltimo retroceso} x[k]:=x[k]+1; {generar siguiente candidata} mq x[k]n and not buenSitio(k,x) hacer x[k]:=x[k]+1 fmq; si x[k] n {se ha encontrado un buen sitio} entonces si k=n {es una solucin completa?} entonces escribir(x) {si: escribirla} sino k:=k+1; x[k]:=0 {ir a la siguiente fila} fsi sino k:=k-1 {retroceso} fsi fmq fin

 Problema de las 8 reinas: otra solucin recursiva

algoritmo reinas
Variables i:entero; q:bool; a:vector[1..8] de bool; {a[i]=ninguna reina en fila i} b:vector[2..16] de bool; {b[i]=ninguna reina en diagonal-/ i} c:vector[-7..7] de bool; {c[i]=ninguna reina en diagonal-\ i} x:vector[1..8] de entero {x[i]=posicin de la reina en la i-sima columna} algoritmo ensaya(ent i:entero; sal q:booleano) fin Principio para i:=1 hasta 8 hacer a[i]:=verdad fpara; {filas que estn libres} para i:=2 hasta 16 hacer b[i]:=verdad fpara; para i:=-7 hasta 7 hacer c[i]:=verdad fpara; ensaya(1,q); para i:=1 hasta 8 hacer escribir(x[i]) fpara Fin {Solucin que se obtiene: 1 5 8 6 3 7 2 4}

 Problema de las 8 reinas: otra solucin recursiva

algoritmo ensaya(ent i:entero; sal q:booleano) variable j:entero {sern usadas: fila j, columna i} principio j:=0; Repetir j:=j+1; q:=falso; si a[j] and b[i+j] and c[i-j] entonces x[i]:=j; a[j]:=falso; b[i+j]:=falso; c[i-j]:=falso; {Registrar} si i<8 entonces ensaya(i+1,q); si not q entonces {Cancelar registro} a[j]:=verdad; b[i+j]:=verdad; c[i-j]:=verdad fsi sino q:=verdad fsi fsi hastaQue q or (j=8) fin .

Algoritmos voraces
Un algoritmo voraz (vido) se basa en construir la
solucin del problema dado en sucesivos pasos, de forma que en cada paso la solucin parcial adoptada sea localmente ptima en algn sentido
En cada etapa, un algoritmo voraz opta por seleccionar la
opcin que supone un ptimo local de acuerdo a una determinada poltica

Un algoritmo o estrategia voraz

No siempre lleva a la solucin globalmente ptima No siempre lleva a obtener solucin (aunque el problema
tenga solucin) Generalmente son rpidos y eficientes

Programacin dinmica
Cuando la resolucin de un problema se alcanza
resolviendo una serie de subproblemas y combinando sus soluciones, puede ocurrir que el mismo subproblema deba resolverse varias veces (ejemplo: Fibonacci), es tal caso, para mantener el algoritmo en tiempo polinmico (evitando dejarlo crecer a exponencial), en lugar de volver a resolver el subproblema cada vez que aparece, se recurre a recordar el subproblema y su solucin:
Se utiliza una tabla para almacenar las soluciones de los
subproblemas. La tabla se rellena independientemente de que el subproblema se vaya a necesitar para resolver el problema principal El esquema de generacin y clculo de una tabla de subproblemas y sus soluciones para obtener la solucin a un problema dado, se ha denominado programacin dinmica (nombre procedente del campo de teora de control)