Parte II Tcnicas de Diseo de Algoritmos

83

85 En este parte se estudiaran diversas tcnicas de diseo de algoritmos. En cada captulo se estudiar una tcnica distinta empezando por ver que tipo de problemas se pueden atacar utilizando la tcnica. Se estudia, adems, el como hacer el anlisis de algoritmos que utilicen dicha tcnica as como ejemplos concretos donde podemos utilizar la tcnica para su solucin. No se pretende realizar un estudio exhaustivo sino presentar las tcnicas mas comunes. Dichas tcnicas son: Dividir para vencer. Mtodo Avido. Bsqueda con retroceso. rboles de juego. A continuacin se presentan cada una de ellas con una breve introduccin Dividir para vencer Mtodo Avido. Bsqueda con retroceso. rboles de jurgo.

86

Captulo 5 Dividir para vencer

Esta tcnica es muy utilizada en la solucin de problemas. Esto se debe a que la idea bsica de esta tcnica es simple. Tenemos un problema complejo al cual dividimos en subproblemas mas pequeos a resolver. Para resolver cada subproblema seguimos el mismo procedimiento hasta que llegamos a un problema que es trivial. Una vez resueltos los subproblemas los combinamos para dar solucin al problema original.

5.1.

Forma genrica

El Algoritmo 15 presenta la forma genrica de un algoritmo diseado utilizando la tcnica de dividir para vencer. El algoritmo recibe un problema p, el tamao de este problema n as como una variable donde se guarda la solucin s. El problema p es dividido en varios subproblemas que se guardan en el vector sp. Para resolver cada subproblema el algoritmos se llama recursivamente donde el subproblema ser a su vez dividido hasta que eventualmente lleguemos al caso donde la solucin es trivial. Una vez resueltos todos los subproblemas se combinan todas las soluciones encontradas (que se han guardado en el vector ssp) en la solucin s. Cuando el tamao del problema es lo sucientemente pequeo se calcula de manera inmediata la solucin. 87

88

CAPTULO 5. DIVIDIR PARA VENCER

proc DividirParaVencer (p,n,s) comienza si pequeo (p, n) entonces otro

CalculaSolucinInmediata(p, n, s)

sp = Divide (p, n, s, t) sp es un arreglo de subproblemas para i = 1 a nmero de subproblemas haz DividirParavencer (sp[i], t[i], ssp[i]) t es un arreglo de tamaos de los subproblemas ssp es un arreglo de soluciones del problema

zah is termina.

Combina(ssp, s)

Algoritmo 15: Dividir para Vencer

5.2. Forma de la Funcin Complejidad

La funcin complejidad para un problema de tamao n es un sistema de ecuaciones recurrentes de la forma

f (m) = fCalculaSolucinInmediata (m)

k

f (n) = fDivide (n) + fCombina (n) +

i=1

f (t[i])

donde m es el valor para el cual la funcin problema pequeo es verdadero y k el nmero de subproblemas, es decir, el nmero de elementos de sp. Esta tcnica es muy utilizada para resolver el problema de ordenar un arreglo de valores as como de bsqueda. A continuacin veremos dos ejemplos de como utilizar dividir para vencer para ordenar un arreglo. Es importante destacar que pese a que la tcnica utilizada es la misma en ambos casos los algoritmos resultantes son diferentes.

5.3. MERGESORT

ORDENAMIENTO POR INTERCALACIN

89

5.3.

Mergesort

Ordenamiento por intercalacin

Ejemplo 27 El ordenamiento por intercalamiento (mergesort), como se muestra en el algoritmo 16, utiliza la tcnica de dividir para vencer de la siguiente manera. Para ordenar un arreglo este se divide en dos mitades, cada mitad es ordenada y ambas mitades ya ordenadas se intercalan para dar la solucin.

proc Mergesort(ini, f in) comienza si ini < f in entonces

is termina.

f in) mitad (ini+ 2 Mergesort(ini, mitad) Mergesort(mitad + 1, f in) Intercala(ini, mitad, f in)

Algoritmo 16: Mergesort

El algoritmo utiliza el hecho de que un arreglo de tamao 1 ya esta ordenado, en el caso base no se realiza ninguna operacin. En el caso recursivo el algoritmo 17 es utilizado para combinar las dos mitades ordenadas en un arreglo ya ordenado.

Anlisis Temporal
Tamao del problema: n, el tamao del arreglo. Operacin bsica: asignaciones entre elementos del arreglo. Primero es necesario hacer el anlisis del algoritmo que intercala, algoritmo 17. El algoritmo hace 2n operaciones. Esto lo podemos ver de manera informal de la siguiente manera. Primero, el algoritmo copia todos los elementos de el arreglo A al arreglo B intercalndolos en orden. Despus, copia los elementos del arreglo B al A ya en orden. Debido a que el algoritmo de ordenamiento no realiza comparaciones se tiene un solo caso. Caso nico:

90

CAPTULO 5. DIVIDIR PARA VENCER

proc Intercala(ini, mitad, f in) comienza

ini1 ini ini2 mitad + f in k1 mientras (ini1 mitad) (ini2 f in) haz si A[ini1 ] < A[ini2 ] entonces B [k ] A[ini1] ini1 ini1 + 1

otro

is

B [k ] A[ini] ini ini2 + 1

zah si ini > mitad entonces para j = ini2 a f in haz zah is para j ini a f in haz termina.
A[j ] B [j ] B [k ] A[j ] k k+1

k k+1

se acabo arreglo izquierdo

Algoritmo 17: Intercala

5.3. MERGESORT

ORDENAMIENTO POR INTERCALACIN

91

f (1) = 0
intercala

f (n) =

n 2n +2f ( ) 2

Si asumimos que n = 2k podemos expandir la recurrencia utilizando el hecho de que n f (n) 2f ( ) = 2n 2 de la siguiente forma

f (2k ) 2f (2k1 ) = 2 2k 2f (2k1 ) 22 f (2k2 ) = 22 2k1 22 f (2k2 ) 23 f (2k3 ) = 23 2k2 . . . 2k2 f (22 ) 2k1 f (21 ) = 2k1 22 2k1 f (21 ) 21 f (20 ) = 2k 21
Sumando todas las ecuaciones tendremos que
k

f (2 ) =
i=1

2k+1 = k 2k+1

pero como asumimos n = 2k eso implica que k = log(n) y por lo tanto

f (n) = log(n) n
es decir

f (n) es O(n log n)

Anlisis Espacial
Memoria esttica.

92

CAPTULO 5. DIVIDIR PARA VENCER

Observamos que en el algoritmo de intercala se necesitan de n celdas para los arreglos A y B. Dado que estas son variables globales es la nica memoria esttica se necesita. Por lo tanto

Fme (n) = 2n + c es O(n)

Memoria dinmica. En el caso de la memoria dinmica debemos saber el nmero de llamadas recursivas realizadas. En este caso la relacin de recurrencia es

n Fmd (n) = c + Fmd ( ) 2

ya que despus de cada llamada recursiva esta libera los recursos que haya utilizado. Por lo tanto de memoria dinmica la funcin es

Fmd (1) = c

Fmd (n) = c log n es O(log n)

5.3.1. Problemas del algoritmo Mergesort.

Existen dos problemas con el algoritmo de ordenamiento por intercalamiento. Estos son 1. Exceso de llamadas recursivas.

Solucin propuesta: Cortar la recursividad en n = 16; utilizar insercin directa. El algoritmo 18 es el algoritmo de insercin directa el cual se puede utilizar para aquellos casos donde n 16.
El anlisis para el algoritmo cambia ya que en el caso base se hace la insercin directa. Este algoritmo si vara de acuerdo a como se encuentren los datos en el arreglo. El anlisis del algoritmo de insercin directa sera de la siguiente manera:

Mejor caso: El arreglo est ordenado de manera ascendente.

En este caso el ciclo mientras nunca se realiza y por lo tanto

Ft (n) = 3(n 1) es O(n)

contando las asignaciones.

5.3. MERGESORT

ORDENAMIENTO POR INTERCALACIN

93

proc InsercinDirecta(ini, f in) comienza para j ini + 1 a f in haz

x A[j ] ij1

mientras x < A[i] i ini haz zah zah termina.

A[i + 1] A[i] ii1

A[i + 1] x

Algoritmo 18: Insercin Directa

Peor Caso: El arreglo est ordenado ascendentemente.
En este caso el ciclo mientras se ejecuta siempre j ini veces. Si suponemos ini = 1 tendremos
n j n

Ft (n) =
j =2

(3 +
i=0

2) =
j =2

3 + 2(j 1)

que es O(n2 ). Para el algoritmo de mergesort lo que cambiara sera el caso base:

si (ini f in + 1 < 16) entonces otro

Y por lo tanto

InsercinDirecta(ini, f in)

...

nmero de llamadas recursivas

Aprox. total de llamadas . 25

2. Utilizacin de un arreglo auxiliar (i.e copiado sistemtico)

solucin propuesta: Usar ligas como sucede en el algoritmo 19.

94

CAPTULO 5. DIVIDIR PARA VENCER

proc Intercala2 (l1 , l2 , lr ) comienza

k0

mientras l1 = 0 l2 = 0 haz si A[l1 ] < A[l2 ] entonces

is zah si l1 = 0 entonces otro is termina.

k l1 ; ligas[k ] l1 ; l1 ligas[k ]; ligas[k ] l2 ; k l2 ; l2 ligas[l2 ];

ligas[k ] l2 ; ligas[k ] l1 ; lr ligas[0];

Algoritmo 19: Intercala con ligas

5.4. QUICKSORT

95

5.4.

Quicksort

Ejemplo 28 Quicksort El algoritmo de ordenamiento rpido (quicksort),

como se muestra en el algoritmo 20, utiliza tambin la tcnica de dividir para vencer. En este caso la estrategia es tomar un elemento como pivote y poner en una parte a los elementos menores al pivote y en la otra a aquellos mayores al pivote. Despus se hacen llamadas recursivas para ordenar ambas partes. En este caso tambin se aprovecha el hecho de que un arreglo de tamao 1 esta ya ordenado.

proc Quicksort(ini, f in) comienza si ini < f in entonces

is termina.

pivote Particin(ini, f in) Quicksort(ini, pivote 1) Quicksort(pivote + 1, f in)

Algoritmo 20: Quicksort

El algoritmo que parte el arreglo en dos partes (no iguales) esta denido en el algoritmo 21. Este algoritmo parte el arreglo en dos partes utilizando al primer elemento del arreglo como pivote.

Anlisis Temporal
Tamao del problema: Tamao del arreglo Operacin bsica: Comparaciones Para hacer el anlisis temporal notamos que el algoritmo particin realiza n comparaciones. De manera informal esto sucede por que el pivote se compara contra todos los elementos del arreglo. Hacemos el anlisis de quicksort caso por caso. Peor Caso: Ocurre cuando el pivote es el primer elemento En este caso el arreglo se divide en dos partes, una de tamao n 1 y otra de tamao 1. Como ya dijimos el arreglo de tamao 1 ya esta ordenado y supongamos que no necesitamos realizar ninguna operacin. Por lo tanto

96

CAPTULO 5. DIVIDIR PARA VENCER

func Particin(ini, f in) comienza

x A[ini]; men ini 1; may f in + 1;

repite repite men men + 1hasta A[men] > x; repite may may 1hasta A[may ] < x; si men < may entonces is hasta men may ;
A[ini] A[may ]; A[may ] x; Particin may ;
Intercambia(men, may )

termina.

Algoritmo 21: Particin

tendremos

f (1) = 0 f (n) = f (1) + f (n 1) +

es decir

n
particin

+1 = f (n 1) + n + 1

f (n) f (n 1) = n + 1
y expandiendo las recurrencias tendremos

f (n) f (n 1) = n + 1 f (n 1) f (n 2) = (n 1) + 1 f (n 2) f (n 3) = (n 2) + 1 . . . f (2) f (1) = 2 + 1

5.4. QUICKSORT sumando las ecuaciones obtenemos

n

97

f (n) =
2

(i + 1) =

n(n + 1) + (n 2) 2

que es O(n2 ). Mejor caso:El pivote esta exactamente a la mitad En este caso el arreglo se divide en dos partes del mismo tamao. Si suponemos que n = 2k cada parte tendr un tamao 2k 1 (por que el pivote ya esta en orden). La gura 9 muestra el rbol de llamadas recursivas que se realizan.

f (2k )

f (2k1 1)

f (2k1 1)

f (2k2 1)

f (2k2 1)

f (2k2 )

f (2k2 )

Figura 9: rbol de Llamadas

En este caso expresamos la relacin de recurrencias como una desigualdad de tal manera que

f (1) 0 n f (n) 2f ( ) + n + 1 2
es decir

n f (n) 2f ( ) n + 1, 2

98

CAPTULO 5. DIVIDIR PARA VENCER

como asumimos n = 2k tendremos

f (2k ) 2f (2k1 ) 2k + 1 2f (2k1 ) 22 f (2k2 ) 2k + 2 22 f (2k2 ) 23 f (2k3 ) 2k + 22 . . . 2k2 f (22 ) 2k2 f (2) 2k + 2k2 2k1 f (2) 2k f (1) 2k + 2k1
por lo tanto
k1

f (2 ) k 2 +
i=0

2i k 2k +

2k1 1 n log n + n 1 2

que es O(n log n). Caso medio: El pivote se distribuye uniformemente en todo el arreglo. Esto signica que las llamadas recurrentes pueden tener las siguientes formas:

f (0) + f (n 1) + n + 1 f (1) + f (n 2) + n + 1 f (2) + f (n 3) + n + 1 . . . f (n 3) + f (2) + n + 1 f (n 2) + f (1) + n + 1 f (n 1) + f (0) + n + 1

Si tomamos todas esas ecuaciones y las sumamos tendremos

f (n) =
es decir

2[f (0) + f (1) + f (2) + + f (n 1)] + n(n + 1) n

nf (n) = 2[f (0) + f (1) + f (2) + + f (n 1)] + n(n + 1).

5.4. QUICKSORT Resolvemos la recurrencia para n 1 y obtenemos

99

(n 1)f (n 1) = 2[f (0) + f (1) + f (2) + + f (n 2)] + (n 1)n

restando la ecuacin para nf (n) y (n 1)f (n 1) obtenemos

nf (n) [(n 1)f (n 1)] = 2f (n 1) + 2n nf (n) = [2 + n 1]f (n 1) + 2n nf (n) = (n + 1)f (n 1) + 2n

Con lo cual obtenemos la relacin de recurrencia

f (1) = 0 n+1 f (n) = f (n 1) + 2 n

Resolviendo la relacin de recurrencia tendremos

f (n) f (n 1) 2 = n+1 n n+1 f (n 1) f (n 2) 2 = n n1 n f (n 2) f (n 3) 2 = n+1 n n1 . . . f (3) f (2) 2 = 4 3 4 f (2) f (1) 2 = 4 2 3

por lo que

f (n) =2 n+1
despejando f (n) tenemos
n+1

n+1

i=3

1 i

f (n) = 2(n + 1)
i=3

1 2(n + 1) i

n+1 3

dx x

100

CAPTULO 5. DIVIDIR PARA VENCER

utilizando aproximacin por integrales. Finalmente tendremos

f (n) 2(n + 1)[log(n + 1) log 3]

que es O(n log n). El algoritmo adolece del exceso de llamadas recursivas, como mergesort. El algoritmo 22 es una versin iterativa del algoritmo.

proc QuicksortIterativo (ini, f in) comienza

zah zah termina.

MetePila(ini, f in) mientras PilaVacia() haz SacaPila(ini, f in) mientras (ini < f in) haz pivote Particin(ini, f in); MetePila(pivote + 1, f in); f in pivote 1;

Algoritmo 22: Quicksort Iterativo

Anlisis Espacial
En el caso del anlisis espacial, la memoria necesitada por el algoritmo de quicksort, tenemos tambin varios casos.

Peor Caso: Se da cuando se tienen sistemticamente problemas de tamao 0 y (n 1) por resolver.

5.5. EJERCICIOS

101

f (1) = c f (n) = c = f (n 1) = O(n) . . . f (n) = c + f (n 1) f (n 1) = c + f (n 2) . . . f (2) = c + f (1) . . . f (n) = c(n)

Mejor Caso: Se da cuando se tienen sistemas problemas de tamao 0 y (n-1) por resolver.

f (n) = c = O(1)
Para ahorrar memoria dinmica: si pivote ini < f in pivote entonces MetePila(pivote + 1, f in) f in pivote 1

otro

is

MetePila(ini, pivote) ini pivote + 1

Introducir el cdigo anterior en el mientras mas profundo.

5.5.

Ejercicios

Ejercicio 5.1 Realice el anlisis espacial para el peor caso de quicksort. Ejercicio 5.2 Par ms cercano. Dado un conjunto de puntos en el plano
cartesiano (x, y ) el problema es encontrar aquellos dos puntos que se encuentran ms cerca el uno del otro. Haga el anlisis del algoritmo.

102

CAPTULO 5. DIVIDIR PARA VENCER

Ejercicio 5.3 Bsqueda en Arboles-B. Un rbol B de orden n es un rbol

cuyo nodo est formado por a lo mas n 1 elementos con n hijos. Los hijos estn ordenados de tal forma que los elementos a la izquierda son menores y a la derecha son mayores. Escriba un algoritmo para hacer bsquedas en arboles B de orden n. Haga el anlisis del algoritmo.
J Q

B C

K L

R S

Figura 5.1: Arbol-B de orden 3

Ejercicio 5.4 Disee un algoritmo para encontrar el mnimo y mximo de

un arreglo utilizando divide y vencers. Haga el anlisis del algoritmo.

Ejercicio 5.5 Elabore un algoritmo para encontrar una moneda falsa en un

arreglo de n monedas. Haga el anlisis de dicho algoritmo. Asuma que conoce la funcin falsa que regresa verdadero si la moneda es falsa y es de orden constante.

Ejercicio 5.6 Dado un rbol binario de bsqueda como el que se ve en la

Figura 5.2 escriba un algoritmo para hacer bsquedas en l. Haga el anlisis de dicho algoritmo. Diga si el orden del algoritmo domina asintticamente a log2 n (el orden de bsqueda para un rbol binario de bsqueda).

5.5. EJERCICIOS

103

10

11

14

Figura 5.2: rbol Binario de Bsqueda

104

CAPTULO 5. DIVIDIR PARA VENCER

Captulo 6 Mtodo vido

El mtodo vido es un mtodo que se utiliza para encontrar la solucin ptima a un problema. La manera de lograrlo es tomar un elemento a la vez e irlo agregando a la solucin siempre que y cuando el hacerlo mantenga la solucin ptima encontrada hasta ese momento. Esto se puede ver en el algoritmo 23.

proc Avido(A, n, sol) comienza

is zah termina.

sol vacia mientras SolCompleta(sol) haz elem seleccion(A) si EsViable (sol, elem) entonces sol sol elem A A elem

Algoritmo 23: Mtodo vido

6.1.

Problemas Tipo

Reciben como entrada un conjunto de elementos, la salida es un subconjunto de esos elementos que cumplen ciertas restricciones. Cada uno de estos 105

106

CAPTULO 6. MTODO VIDO

subconjuntos es llamado una solucin factible o viable. Se requiere encontrar una solucin factible que maximice o minimice una funcin objetivo. Esta solucin es llamada la solucin ptima. En la mayora de los casos es necesario probar que la estrategia de solucin adoptada conduce a una solucin ptima. Esta tcnica se utiliza para resolver una gran cantidad de problemas de optimizacin. En cada uno de ellos identicamos la funcin objetivo y se demuestra que la estrategia nos conduce a la solucin ptima.

6.2. Almacenamiento en Cintas

Ejemplo 29 El problema del almacenamiento ptimo con cintas es el siguiente. Se tienen n programas en una cinta de longitud L, cada programa i tiene una longitud li , 1 i n. Claramente
n

li L.
i=0

Asumimos que cada vez que se desea leer un programa, la cinta se lee desde el comienzo. Es decir, que si los programas se encuentran almacenados en el orden I =< i1 , i2 , . . . , in > el tiempo necesario para recuperar el programa k es
k

tk
j =1

lij .

El tiempo promedio esperado de lectura (TPEL) es entonces

1 TPEL = n

k=1

1 lij = n j =1

(n k + 1)lik
k=1

Funcin objetivo
Encuentra un orden para almacenar los programas de tal manera que el TPEL sea el menor posible.

6.2. ALMACENAMIENTO EN CINTAS

107

proc AOC (l, n, Ord) comienza

zah termina.

Ord vacio; i 1; mientras (i n) haz p ProgramaMasPequeo (l); Ord[i] p; i i + 1;

Algoritmo 24: AOC Estrategia

El algoritmo 24 utiliza la estrategia de tomar al programa que tenga la menor longitud e ir la agregando a la solucin los programas de tal manera que la solucin se mantenga ptima, es decir en orden ascendente.

Teorema 13 EL algoritmo AOC encuentra el ordenamiento que minimiza

n k

TPEL. Si l1 l2 l3 ln entonces el orden < 1, 2, 3, . . . , n > minimiza

lj
k=1 j =1

sobre todas las permutaciones de programas.

de ndices {1, 2, 3, . . . , n}. Entonces sea D(I ) ptima de tal forma que
n

Demostracin 9 Sea I =< i1 , i2 , . . . , in > una permutacin del conjunto

D(I ) =
k=1

(n k + 1)lij .

Deben existir en I un par de ndices a, b tales que a < b y lia > lib .

108

CAPTULO 6. MTODO VIDO

Si permutamos los programas a y b tendremos D(I ) tal que

n

D(I ) =
k=1

(n k + 1)lij + (n a + 1)lib + (n b + 1)lia

D(I ) D(I ) = (n a + 1)lia (n b + 1)lia + (n b + 1)lib (n a + 1)lib = (b a)lia + (a b)lib = (b a)(lia lib ) > 0
contradiccin

El ptimo esta dado por el orden < 1, 2, 3, . . . , n > .

6.3. Problema de la mochila

Ejemplo 30 Problema de la mochila se plantea de la siguiente forma. Se
tienen n objetos y una mochila. Cada objeto tiene un peso pi y un valor vi 1 i n. La mochila tiene una capacidad M . El problema consiste en seleccionar los objetos o (fracciones de ellos) tales que
n

xi v i
i=1

tenga un valor mximo cumpliendo 0 xi 1 y

n

xi pi M, vi > 0, pi > 0, 1 i n
i=1

Supongamos que n = 3, M = 20 y

(v1 , v2 , v3 ) = (24, 25, 15) (p1 , p2 , p3 ) = (18, 15, 10)

6.3. PROBLEMA DE LA MOCHILA podremos tener en nuestra mochila

109

xi v i 1 1 1 ( , , ) 2 3 4 5 ( , 1, 0) 18 2 (0, , 1) 3
y en particular

pi vi 16.5 20 20

24 31.6 31.6

24 25 15 4 5 3 , , )=( , , ) 18 15 10 3 3 2

tomando los objetos por mayor unidad de peso

1 = (0, 1, ) 2 = 32.5

Estrategia
Tomar los objetos de mayor valor por unidad de peso. El algoritmo 25 muestra el algoritmo para resolver el problema de la mochila utilizando el mtodo vido.

Teorema 14 Si
ptima.

vi v2 vn ... el algoritmo Mochila genera la solucin pi p2 pn

Sea x = (x1 , x2 , . . . , xn ) la solucin generada por el algoritmo. Sea j el primer ndice tal que xj = 1 xi = 11 i < j, y 0 xj 1 con xi = 0j < i n. Supongo que existe una solucin ptima Y = (y1 , y2 , y3 , . . . , yn ) Recorremos X y Y hasta encontrar el primer ndice k tal que xk = yk . Puede pasar que 1. k < j yk < xk

110

CAPTULO 6. MTODO VIDO

proc M ochila(p, v, x, k, M ) comienza

i 0; peso 0; valor 0; ordena(p, v, ppv ); mientras peso < M haz k ppv [i]; si p[k ] < (M peso) entonces x[k ] 1

otro

x[k ]

is

(M peso) ; p[k ]

zah termina.

peso peso + x[k ] p[k ]; valor valor + v [k ] x[k ]; i i + 1;

Algoritmo 25: Mochila

6.3. PROBLEMA DE LA MOCHILA 2. k > j yk < xk 3. k = j

111

Si k existe yk < xk . Pero eso tambin implica que l tal que l > k y yl = 0. Construimos ahora una Y tal que Y y Y son idnticas excepto en y yl = yl con lo cual los ndices k y l. Sustituimos yk = yk + pk pl
n n

yi pi =
i=1 i=1

yi pi

Note que

yk p k = ( yk +
y

pk

)pk = yk +

yl p l = ( yl +

pl

)pl = yl

Si hacemos yk tan grande como podamos tendremos dos posibilidades: 1. yk = xk 2. yk < xk en cuyo caso existe l tal que l > k y yl = 0 y podemos hacer el razonamiento superior hasta hacer yk = xk . Pero, qu pasa con la suma de valores? Para ellas tendremos
n n

yi pi
i=1 i=1

yi pi

Por que

yk vk = yk vk + y l vl = y l vl

pk pl

vk

vl

112 y

CAPTULO 6. MTODO VIDO

vk vl > pk pl
Es decir que podemos hacer Y idntico a X hasta k y mantenerlo ptimo. Es claro que podemos seguir este razonamiento para k + 1, k + 2 . . . , n. X es ptimo. Construiremos una solucin Z en la cual vamos a hacer crecer yk hasta xk y decrecer yk+1 , ..., yn . Tendremos por lo tanto:
n n

v i xi =
i=1 i=1

vi yi + (yk Xk )vk
n

pi pk (yi xi )vi xk i=k+1 pi vi yi + [(yk xk )pk (yi xi )pi ] vk pk

i=1

!
i) >! y es optima ii) Z es optima y se parece a x hasta xk , si aplicamos el mismo procedimiento tendremos z xk + 1X

x es optima

6.4. Intercalacin ptima de archivos

Ejemplo 31 Sabemos que intercalar 2 archivos ordenados de longitud n y
m respectivamente cuesta O(n + m). El problema de intercalacin ptima es cuando se desea mezclar n archivos ordenados.
Para n archivos hay varias maneras de hacer la intercalacin: Se puede proceder por pares de archivos, ordenndolos de acuerdo a tu tamao, intercalando elementos de todos a la vez, etc. Lo primero que debemos tratar es ver como hacer el intercalamiento.

6.4.1. Problema
Determinar la manera ptima de intercalar los registros de los n archivos ordenados.

6.4. INTERCALACIN PTIMA DE ARCHIVOS

113

6.4.2. Estrategia
Tomar cada vez los dos archivos mas pequeos. Este problema puede representarse como un rbol binario en el que las hojas son los archivos iniciales y los nodos internos las intercalaciones, la Figura 10 muestra un ejemplo. Si F1 esta a una distancia de 3 los registros de Fi se movieron tres veces. Si di es la distancia del nodo Fi a la raz y li es la longitud del archivo Fi entonces el nmero total de movimientos es
n

li di
i=1

que es la longitud del camino externo ponderada.

y3

y3

y2

y1

y2

y1

x1

x2

x3

x4

x1

x2

x3

x4

Figura 10: Problema de intercalacin ptima visto como rbol

Un rbol de intercalacin ptimo corresponde a un rbol binario con longitud de camino externo ponderado mnimo. El algoritmo 26 muestra un algoritmo vido de intercalamiento ptimo.

Teorema 15 Si L inicialmente contiene n 1 nodos con longitud (l1 , l2 , l3 , . . . , ln )

el algoritmo IOA genera un rbol de intercalacin ptimo de dos en dos para n archivos con esas longitudes.

Demostracin 10 Suponemos que existe T un rbol de intercalamiento ptimo.

114

CAPTULO 6. MTODO VIDO

proc IOA(L, n) comienza para i = 1 a n 1 haz

zah termina.

nodo Creanodo(); Izq (nodo) M enor(L); menor elimina el Der(nodo) M enor(L); nodo de vuelta Long (nodo) Long (Izq (nodo) + Long (Der(nodo)); Inserta(L, nodo);

Algoritmo 26: Algoritmo de Intercalacin vido

Sea P un nodo interno de distancia mxima a la raz como el que se muestra en la gura

Observemos que el algoritmo genera en la primera iteracin

<-P

l1 + l2

lr

lm

l1

l2

Si intercambiamos l1 y l2 con lr y ln , la longitud de camino externo ponderado del rbol resultante T es LCEP(T ) LCEP(T ). Adems:

6.4. INTERCALACIN PTIMA DE ARCHIVOS

115

Si LCEP(T ) = LCEP(T ) entonces l1 , l2 , lr , ln estn en el mismo nivel. Si LCEP(T ) > LCEP(T ) estaban en diferentes niveles. Contradiccin!

6.4.3. Generalizacin a arboles de grado k

Notemos que

mod (k 1) = 1

Por lo que a lo mas se tienen que agrupar k 2 archivos comodines de longitud 0.

6.4.4. Aplicacin : Cdigo de Human

Si en lugar de longitudes tenemos frecuencias a=000 b=001 c=01 d=10 e=11 60

25

35

15

20

30

30

10

116

CAPTULO 6. MTODO VIDO

6.5. Arboles Generadores mnimos

Ejemplo 32 Un rbol generador mnimo se dene as. Sea G =< V, A >
un grafo conectado no dirigido. Un subgrafo T =< V, A > de G es un rbol generador de G si T es un rbol (A A y T no tiene ciclos). Si cada arco a tiene un costo c(a) entonces el costo del rbol T ser

c(T ) =
aA

c(a)

El problema es encontrar un rbol generador de costo mnimo.

6.5.1. Problema
Encontrar un rbol generador de costo mnimo.
71 0 6 53 2 4 G
5

71 0 6 53 2 4 E

71 0 6 53 2 4 G 71 0 6 53 2 4 A
3 3

0 71 6 53 2 4 E

0 71 6 5? 2 4 3 2 A  ??? 6  ??  3 ??   3 0 2 0 71 6 53 2 4 71 0 6 5 2 4 3 7 6 1 5 2 4 3 B C ?? F ??   ?? 5  6 ? ?  5 8 ?> 9 : =< ; D

7

71 0 6 53 2 4 C

71 0 6 53 2 4 2 0 71 6 53 2 4 F B      5 8 ?> 9 : =< ; D

Figura 11: Grca y su rbol generador de costo mnimo

6.5.2. Estrategia
Existen dos estrategias bsicas Tomar el arco de menos costo que una un vrtice conectado con uno no conectado. Toman el menor arco que no forme ciclo. El algoritmo de Kruskal que se muestra en el algoritmo 27 utiliza la segunda estrategia para encontrar un rbol generador de costo mnimo.

6.5. ARBOLES GENERADORES MNIMOS

117

proc Kruskal (G, A, n) comienza

A vacio; para i = 1 a n 1 haz arco M enor(G); si F ormaCiclo(arco, A) entonces A A arco;

zah termina.

is

Algoritmo 27: Kruskal Teorema 16 El algoritmo de Kruskal genera un rbol generador de costo
mnimo para un grafo conectado no dirigido G.

Demostracin 11 Usamos las siguientes suposiciones:

Suponemos que existe T un rbol generador de costo mnimo. Sea a el arco de menor costo considerado en Tk (el rbol generado por el algoritmo de Kruskal) que no esta en T. Observamos que si agregamos el arco a a T tenemos un ciclo nico. En ese ciclo nico, hay un arco a que esta en T y que no esta en Tk (sino Tk tendra un ciclo). Observamos que c(a) c(a ). Si construimos un rbol T cambiamos a por a.

c(T ) = c(T ) + c(a) c(a ) c(T ) c(T )

El rbol obtenido sigue siendo generador y ptimo c(T ) c(T ). Podemos seguir este razonamiento hasta que T = Tk . Tk es ptimo.

118

CAPTULO 6. MTODO VIDO

Captulo 7 Bsqueda con retroceso (Backtrack)

Esta tcnica se utiliza en algoritmos de bsqueda. Los algoritmos diseados en base a esta tcnica pueden realizar una bsqueda exhaustiva de un espacio grande de bsqueda (del orden n! o an cn ). Para ser efectiva normalmente deben de utilizarse heursticas que permitan reducir el espacio de bsqueda tanto como sea posible. El principio es sencillo, tratar todas las soluciones posibles para un problema.

7.1.

Problemas Tipo
(x1 , x2 , x3 , ..., xn ), xi Si

La solucin se expresa como una tupla

y debe satisfacer una funcin objetivo

F (x1 , x2 , x3 , ..., xn ).
Cada uno de los valores xi de la tupla puede tomar uno de varios posibles valores Si . Si |Si | = mi entonces existen m1 m2 m3 mn posibles valores para (x1 , x2 , x3 , ..., xn ). 119

120

CAPTULO 7. BSQUEDA CON RETROCESO (BACKTRACK)

7.2. Mtodo de Solucin

Existen dos formas adicionales de buscar soluciones a este tipo de problemas: 1. Mtodo vido. 2. Explorar todo el espacio de soluciones. En el caso del mtodo vido solo encontramos una solucin si existe una estrategia que nos permita usar el mtodo vido. Cosa que no siempre sucede. Explorar todo el espacio de soluciones por otro lado puede resultar demasiado costoso y por tanto nunca encontrar una solucin. El mtodo de bsqueda con retroceso construye las tuplas elemento por elemento y en cada paso evala la tupla parcial para decidir si puede llagar a ser una solucin. En caso de no ser as la tupla parcial es eliminada. Si la tupla parcial es x1 , x2 , x3 , . . . , xk se eliminan mk+1 mk+2 . . . mn tuplas por explorar. Sobre una tupla existen dos tipos de restricciones.

Restricciones explicitas Determinan los valores de los componentes de la

tupla.

Restricciones implcitas Determinan si una tupla es o no una solucin.

Dicen como se relacionan los elementos de la tupla entre ellos. El espacio de soluciones en el conjunto de tuplas denido por las restricciones explicitas. Este espacio se puede representar por un rbol como se muestra en la gura 12. En la raz tenemos a la solucin vaca. En cada nivel elegimos entre los posibles valores xi . En el nivel 1 elegimos a un posible x1 , ya que lo elegimos en el nivel 2 elegimos a un posible x2 y as sucesivamente. En el rbol que representa el espacio de soluciones cada nodo representa un estado del problema. Llamaremos estados solucin a aquellos cuyo camino desde la raz hasta el nodo dene una tupla en el estado de soluciones. Un estado solucin es un estado respuesta si la tupla denida por el camino desde la raz hasta el nodo satisface las condiciones implcitas. Al rbol que representa el espacio de soluciones lo llamaremos rbol de espacio de estados. Un nodo vivo en la generacin del rbol de es un nodo que aun no se descarta. Un nodo muerto es un nodo descartado y el nodo que se esta explorando actualmente es el e-nodo. Para resolver un problema con backtrack

7.2. MTODO DE SOLUCIN Sol =S x3 1 2 1 2 3

121

Figura 12: Espacio de soluciones

se tiene que generar sistemticamente el rbol de espacio de estados a partir de la raz. Hay esencialmente dos maneras de generar el rbol de espacio de estados a partir de la raz: a) Tan pronto como un hijo S del e-nodo R es generado, S se convierte en el nodo e-nodo. R volver a ser el n-nodo una vez que el subrbol con raz en S sea explorado (bsqueda en profundidad). b) El n-nodo deja de serlo hasta que se convierte en un nodo muerto (bsqueda por nivel). En ambos casos se utilizan funciones de corte para matar nodos y as evitar la construccin completa del rbol de espacio de estados: A la generacin del rbol de espacio de estados a profundidad con funciones de corte se le llama backtracking o bsqueda con retroceso. A la generacin del rbol de espacio de estados de acuerdo a la segunda tcnica se le llama branch & boundo (ramicacin y acotamiento). El Algoritmo genrico para la generacin del rbol espacio de estados por Backtrack se muestra en el algoritmo 28.

122

CAPTULO 7. BSQUEDA CON RETROCESO (BACKTRACK)

proc Backtrack (n) comienza

nivel 1;

mientras nivel > 0 haz si xk T (x1 , x2 , . . . , xi ) Bi (x1 , x2 , . . . , xi ) entonces si (x1 , x2 , . . . , xk ) entonces is

es un camino al estado respuesta

imprime(x1 , x2 , . . . , xk ); nivel nivel + 1;

otro is zah termina.

nivel nivel 1;

Algoritmo 28: Backtrack

Sea x1 , x2 , . . . , xk un camino desde la raz hasta un nodo en el rbol de espacio de estados, T (x1 , x2 , . . . , xi ) es una funcin que regresa el conjunto de todos los posibles valores para xi+1 tales que (x1 , x2 , . . . , xi+1 ) es tambin un camino a un estado del problema. Bi (x1 , x2 , . . . , xi ) es una funcin tal que Bi es falsa si (x1 , x2 , . . . , xi ) no puede ser extendido para alcanzar un estado respuesta. El Algoritmo genrico para la generacin del rbol espacio de estados por Backtrack en forma recursiva se muestra en el algoritmo 29.

7.3. n Reinas
Ejemplo 33 El problema de las n reinas consiste en colocar n reinas en
un tablero de ajedrez de n n de manera que no se ataquen mutuamente. La solucin se puede expresar como la tupla de posiciones de las reinas (q1 , q2 , . . . , qn ). Si cada posicin es representada como (r, c) (rengln, colum-

7.3. N REINAS

123

proc RBacktrack (n) comienza para cada xk T (x1 , x2 , . . . , xi ) haz si Bk (x1 , x2 , . . . , xk ) entonces si (x1 , x2 , . . . , xk ) entonces is is zah termina.

es un camino al estado respuesta

imprime(x1 , x2 , . . . , xk );

RBacktrack (nivel + 1);

Algoritmo 29: Backtrack Recursivo

na) tendremos un total de

n2 n
posibles soluciones. Pero si notamos que cada reina debe estar en un rengln diferente (las reinas atacan cualquier pieza en su mismo rengln) entonces la solucin se puede expresar como (c1 , c2 , c3 , . . . , cn ) donde ci es la columna en la que se coloca a la reina en el rengln i. Lo cual reduce nuestro espacio de soluciones a solo n! (por que dos reinas no pueden estar en la misma columna).

7.3.1. Restricciones explicitas

Al denir el problema de la segunda forma declaramos de manera explicita que las reinas deben estar en diferente columna

ci = cj i = j, 1 i, j n.

7.3.2. Restricciones implcitas

La restriccin implcita, las tuplas que son solucin, son aquellas donde las reinas no se atacan. Ya nos aseguramos que las reinas no estn en el mismo

124

CAPTULO 7. BSQUEDA CON RETROCESO (BACKTRACK)

rengln ni en la misma columna. Solo falta asegurarse de que las reinas deben estar en diferente diagonal. Eso lo logramos vericando que

|cj ci | = |j i|.
El algoritmo coloca (algoritmo 30) se encarga de vericar que las restricciones explicitas e implcitas se cumplan. El algoritmo checa que la ltima reina en colocarse (la xi+1 ) cumpla con las restricciones. Este algoritmo es la implementacin de la funcin B para el problema de las n reinas.

func Coloca(reinas) comienza para i = 1 a reinas 1 haz si (x[i] = x[reina] |x[i] x[reina]| = |i reina|) entonces zah is
Coloca f also;

termina. Algoritmo 30: Verica que la reina se pueda colocar

Ya que tenemos un algoritmo para decidir si dado un estado es posible llegar a un estado respuesta solo necesitamos producir los posibles valores de las reinas para cada estado. El espacio de soluciones del problema de las (n=4) reinas se puede representar por el rbol en la gura 13.

Coloca verdadero

c2 =1 4 3 1 2

Figura 13: Espacio de Soluciones para Reinas 4

7.4. SUMA DE SUBCONJUNTOS

125

Como se ve en la gura solo es necesario generar todos los posibles valores de columnas para obtener el siguiente estado. El algoritmo 31 muestra el algoritmo necesario para encontrar la solucin para n reinas. En cada estado se generan todas las posibles columnas y se utiliza la funcin Coloca para vericar si es posible alcanzar un estado respuesta.

proc Reinas(n) comienza

reina 1 x[reina] 0 mientras reinas > 0 haz x[reina] x[reina] + 1; mientras (x[reina] n) Coloca(reina) haz x[reina] x[reina] + 1

zah si (x[reina] n) entonces si (reina = n) entonces otro is

imprime(x); reina reina + 1; x[reina] 0;

otro is zah termina.

reina reina 1;

Algoritmo 31: Solucin a las n Reinas

7.4.

Suma de Subconjuntos

los subconjuntos tales que la suma de los elementos sea igual a un entero M . Por ejemplo, para el conjunto

Ejemplo 34 Se tiene un conjunto de enteros V y se desea encontrar todos

{11, 13, 24, 7} y M = 31

126

CAPTULO 7. BSQUEDA CON RETROCESO (BACKTRACK)

tendremos las soluciones siguientes:

S1 = {11, 13, 7} S2 = {24, 7}

Este problema se puede formular de dos maneras distintas, aunque en ambos casos tendremos al conjunto representado como un vector

< v1 , v2 , v3 , . . . , vn > .

7.4.1. Formulacin 1
Podemos representar la solucin con

(x1 , x2 , x3 , . . . , xk )
donde xi en (x1 , x2 , x3 , . . . , xk ) signica que vxi esta en la tupla. As las soluciones para el ejemplo se expresan

S1 = (1, 2, 4) S2 = (3, 4)
Para generar las posibles tuplas solo necesitamos hacer que

xi 1, 2, 3, . . . , n
y que la tupla

(x1 , x2 , x3 , . . . , xk )
satisfaga
n

vxi = M.
i=1

7.4.2. Restricciones
Para esta formulacin del problema tendremos que las restricciones que tenemos son

7.4. SUMA DE SUBCONJUNTOS

127

Explicitas 1 xi ni y

vxi = M.
i=1

Implcitas Ningn nmero puede aparecer dos veces en la tupla.

El algoritmo 32 resuelve el problema utilizando este planteamiento del problema.

proc Subconjuntos (elem, vacum, resto) comienza

x[elem] 1; si vacum + v [elem] = M

entonces

otro

imprime(x);

si (vacum + v [elem] + v [elem + 1]) M entonces is

Subconjuntos (elem + 1, vacum, resto v [elem]);

is

x[elem] 0; si (vacum + v [elem]) M (vacum + resto v [elem])

entonces

is termina. Algoritmo 32: Subconjuntos para primer planteamiento

Subconjuntos (elem + 1, vacum, resto v [elem]);

7.4.3. Formulacin 2
La solucin ser una tupla

(x1 , x2 , x3 , . . . , xn ) con xi 0, 1
y si xi = 1 signica que vi esta en el subconjunto. Si xi = 0 signica que vi no esta en el subconjunto. La tupla (x1 , x2 , x3 , . . . , xn ). As las soluciones

128

CAPTULO 7. BSQUEDA CON RETROCESO (BACKTRACK)

para el ejemplo se expresan

S1 = (1, 1, 0, 1) S2 = (0, 0, 1, 1)
que debe cumplir
n

xi vi = M.
i=1

7.4.4. Restricciones
Para esta formulacin del problema tendremos que las restricciones que tenemos son

Explicitas
xi = 0 1
y

vxi = M.
i=1

Implcitas En este caso no existe ninguna restriccin implcita.

El algoritmo 33 resuelve el problema utilizando este planteamiento del problema. Considerando
k k

v i xi +
i=1 k i=k+1

vi < M

vi xi + vk+1 > M
i=1

7.5. Coloreado de grcas

Ejemplo 35 Sea G un grafo y m un nmero entero positivo de colores. El
problema de coloreado de grcas consiste asignar a cada vrtice en G un color de manera que ningn par de vrtices adyacentes tengan el mismo color. (El problema de encontrar el nmero ms pequeo para colorear una grca es conocido como el problema de optimizacin de m-coloreabilidad, m es llamado el nmero cromtico de G)

7.5. COLOREADO DE GRFICAS

129

proc Subconjuntos (elem, vacum) comienza para i = 0 a 1 haz entonces

x[elem] i; si vacum + v [elem] i = M imprime(x);

otro

si vacum + v [elem] i < M entonces is

Subconjuntos (elem + 1, vacum + v [elem] i);

zah termina. Algoritmo 33: Subconjuntos para segundo planteamiento

is

7.5.1. Solucin
Expresamos a la solucin como la tupla (x1 , x2 , x3 , . . . , xn ) con xi {1, . . . , m} donde xi es color asignado al vrtice i, por lo que vemos a V como un vector < v1 , v2 , . . . , vn > con |V | = n. La restriccin se expresa como

xi = xj i = j si (i, j ) A.
El rbol de espacio de estados:

130

CAPTULO 7. BSQUEDA CON RETROCESO (BACKTRACK)

func SeColorea(nodo) comienza para vrtice = 1 a nodo 1 haz si (G[vertice, nodo]) (x[vertice] = x[nodo]) entonces zah is
SeColorea F ;

termina.

SeColorea V ;

Algoritmo 34: SeColorea

proc m-coloreado (n, m) comienza

nodo 1; x[nodo] 0; mientras nodo > 0 haz

repite

x[nodo] x[nodo] + 1; hasta x[nodo] > m sepuedecolorear(nodo); si (x[nodo] =< m) entonces si (nodo = n) Imprime(x);

otro is

nodo nodo + 1; x[nodo] 0;

otro is zah termina.

nodo nodo 1;

Algoritmo 35: m-coloreado

7.5. COLOREADO DE GRFICAS

131

proc RMColoreado (nodo, color, m) comienza para color = 1 a m haz

x[nodo] color; si sepuedecolorear(nodo)

entonces si (nodo = n) entonces is

imprime(x); RMColoreado (nodo + 1);

zah termina.

is

Algoritmo 36: m-coloreado recursivo

132

CAPTULO 7. BSQUEDA CON RETROCESO (BACKTRACK)

Captulo 8 rboles de juego

Una variante de la tcnica de backtrack son los rboles de juegos. Estos se utilizan para programar que la computadora juegue partidas de cosas que van desde gato hasta ajedrez. Las principales caractersticas son: 2 jugadores alternan las jugadas el estado del juego se puede representar por una conguracin especca. suponemos un nmero innito de conguraciones. el juego tiene reglas que aseguran su terminacin. A cada uno de estos juegos se le asocia un rbol de juego (rbol de espacio de estados) en donde la raz es la conguracin de partido y los hijos de cada nodo son las posibilidades de tiro a partir de ese nodo. Las hojas del rbol de juego representan las conguraciones en donde alguno de los coecientes ya gan o donde hay una situacin de empate.

8.1.

Problema

Encontrar un camino hacia el triunfo del jugador que tiene el turno en la raz del rbol. 133

134

CAPTULO 8. RBOLES DE JUEGO

8.2. Solucin
Hacer la bsqueda con retroceso en el rbol de juego utilizando el mtodo MiniMax, y las funciones de corte dadas por la tcnica poda alfa-beta.

8.3. Mtodo Min-Max

A cada hoja del rbol de juego se le asigna un valor que puede ser k, 0 o k (k constante).

k si la computadora pierde. 0 si es empate. k si la computadora gana.

Los valores se propagan hacia arriba en el rbol de acuerdo a las reglas: Si un nodo corresponde a una posicin en el tablero donde hay un movimiento de la computadora, el valor ser el mximo de los valores de los nodos hijos. Es decir, se supone que la computadora har el movimiento ms favorable para ella, o sea que produce el resultado con mayor valor. Si el nodo corresponde a una posicin del tablero donde hay un movimiento del usuario, entonces el valor ser el mnimo de los valores de los nodos hijos. Es decir, se presume que el usuario har el movimiento que le cause ms dao. Si la raz tiene un valor k , la computadora tiene una estrategia ganadora a partir de la conguracin inicial del juego. Si tiene un valor 0, entonces ningn jugador tiene una estrategia ganadora. Si tiene un valor k el usuario tiene una estrategia ganadora. El algoritmo 37 es un algoritmo genrico para evaluar un rbol de juego. Recibe como parmetro el modo en que se evalua la funcin (Min o Max).

8.4. Funciones de Utilidad

Es una funcin que permite evaluar la probabilidad de que la computadora gane a partir de la conguracin de la raz.

8.4. FUNCIONES DE UTILIDAD

135

proc Eval (T ab, M odo) comienza si hoja(T ) entonces otro

Eval utilidad(T );

si M odo = M ax entonces otro

valor ; valor ;

is para cada H hijos(T ) haz si (M odo = M ax) entonces otro is zah is termina.

valor M ax(Eval(H, M in), valor); valor M in(Eval(H, M ax), valor);

Eval valor;

Algoritmo 37: Evala MiniMax

136

CAPTULO 8. RBOLES DE JUEGO

8.5. Gato (n-en lnea)

Ejemplo 36 El juego de n-en lnea se juega as. Dado un tablero de n n
cada jugador se turna poniendo un smbolo en el tablero (usualmente y ). El jugador que logre poner n smbolos en lnea primero gana. Al 3-en lnea tambien se le conoce como gato.

8.5.1. Poda alfa-beta

La poda alfa-beta trata de reducir el tamao del rbol usando valores nales y tentativos para cada nodo. Estos se denen de la siguiente manera:

valor nal resulta de la aplicacin de la evaluacin Min-Max. valor tentativo es una cota inferior de valor nal para nodos Max es una cota superior del valor nal para nodos Min.

8.5.2. Reglas
Si todos los hijos de un nodo T ya se podaron o se exploraron entonces valor nal(T)<-valor tentativo Vf H Si un nodo T tiene un valor vt y uno de los hijos de T , el nodo H tiene un valor nal vf H . i) T es un nodo Max y vt < vf H vt vf H . ii) T es un nodo Min y vt > vf H vt vf H . Si un nodo T tiene un valor tentativo vf T y su descendiente, el nodo H tiene un valor tentativo vf H i) T es un nodo Max vtT considerados de H. ii) T es un nodo Max vtT considerados de H.

vtH se podan todos los hijos no vtH se podan todos los hijos no

Captulo 9 Complejidad de los algoritmos diseados con Backtrack.

Depende de: 1. La cantidad de trabajo realizada para solucionar el siguiente valor de la entrada que se est considerando. 2. La cantidad de valores existentes para la siguiente entrada |Si|. 3. La cantidad de trabajo necesaria para determinar si una solucin parcial nos lleva a un nodo supuesto. 4. La cantidad de soluciones parciales que satisfacen la funcin de evaluacin B. Observe que : los puntos 1, 2, 3 no dependen de la instancia del problema ; 4 si depende. En el problema donde se pide encontrar una solucin, un algoritmo de backtrack genera al menos O(n) estados. En el peor de los casos un algoritmo de backtrack explora la totalidad del rbol. - O(p(n)n!) reinas subconjuntos - O(2n ) En los ejemplos anteriores: coloreado - O(p(n)mn ) 137

138CAPTULO 9. COMPLEJIDAD DE LOS ALGORITMOS DISEADOS CON BACKT

9.1. Planicacin y Acotamiento

Generacin del rbol de espacio de estados en donde el nodo en expansin (e-nodo) deja de serlo slo cuando se convierte en nodo muerto. El algoritmo 38 muestra su forma general.

proc RamaAcota(raiz ) comienza

nodo raiz ; Q Colavacia(); Encola(Q, nodo); mientras Escolavacia(Q) HaySolucin haz nodo Desencola(a); si nodo es solucin entonces imprime(nodo); HaySolucin verdad;

otro

para cada hijoHdenodo haz si la solucin parcial (incluyendo H) is zah

conduce a un nodo respuesta entonces Encola(Q, H )

is zah termina.

Algoritmo 38: Planicacin y Acotamiento

9.1.1. Problema de la ramicacin y acotamiento

Entre los problemas que podemos encotrar para este algoritmo tenemos que hace bsquedas ciegas. Si se pudiera calcular la cantidad del trabajo necesaria para llegar a la solucin a partir de un nodo dado, se hace el clculo para todos los nodos vivos y se toma el nodo con menor valor para continuar la bsqueda.

9.1. PLANIFICACIN Y ACOTAMIENTO

139

9.1.2. Bsqueda de menor costo

La cantidad de nodos que se debe generar para encontrar la solucin. La cantidad de niveles que hay que descender para llegar a la respuesta. Si estas funciones estn disponibles entonces Se genera el mnimo de nodos. Se generan slo nodos que conducen a un estado respuesta.

Problema: Esas funciones no son prcticas. Solucin: Estimar la cantidad de trabajo.

A cada nodo T se le asigna un costo con la siguiente funcin

(T ) = h(g ) + g C (T )
donde

h(T ): Cantidad de trabajo necesaria para llegar de la raz a T . g (T ): Una estimacin de la cantidad de trabajo necesaria para llegar de T a un nodo respuesta.
El algoritmo 39 muestra al algoritmo general utilizando estas funciones.

140CAPTULO 9. COMPLEJIDAD DE LOS ALGORITMOS DISEADOS CON BACKT

proc BusquedaMenCosto (raiz ) comienza

nodo raiz ; inserta(vivos, nodo); mientras N ovacio(vivos) Haysolucion haz nodo traeM enoryelimina(vivos); inserta(muertos, nodos); si nodoessolucion entonces imprime(nodo); Haysolucion verdad;

otro

para cada hijoHsucesordenodo haz entonces

ca ux c( H ); si Encuentra(vivas, H ) Hn odo.costo > ca ux H.costo ca ux; Esta v ;

otro

si Encuentra(M uertos, H ) H.nodo.costo > ca ux entonces

H.costo ca ux; Eliminar(M uertos, H ); Inserta(vivos, H ); Esta v ;

is si esta entonces is is zah termina. zah

inserta(vivos, H );

is

H.costo ca ux;

Algoritmo 39: Busqueda Menor Costo