You are on page 1of 44

Instituto Tecnolgico de Ciudad Madero

Dra. Laura Cruz Reyes


Captulo 3 Complejidad de algoritmos recursivos

Unidad I COMPLEJIDAD DE ALGORITMOS

Captulo 3 Complejidad de algoritmos recursivos


3.1 Definicin de funcin de recurrencia
Una recurrencia es una ecuacin o una desigualdad que describe una funcin en trminos de
su propio valor sobre entradas ms pequeas. Por ejemplo, el clculo del Factorial de un
nmero se puede describir con la ecuacin de recurrencia F(n).

nF (n 1) if n > 0
F (n ) =
1
if n = 0

La solucin del Factorial de 4 se puede obtener siguiendo las reglas de la ecuacin de


recurrencia.

F(4) = 4F(3)
F(3) = 3F(2)
F(2) = 2F(1)
F(1) = 1F(0)
F(0) = 1
F(4) = 43211 = 24
Una recurrencia es lineal, si cada llamada recursiva genera cuando mucho otra llamada
recursiva, en caso contrario es no-lineal.
3.2 Deduccin de recurrencias a partir de algoritmos
Los recursos empleados por algoritmos recursivos (por ejemplo, el nmero de comparaciones
de clave y el nmero de multiplicaciones) se pueden describir con la recurrencia T(n), la cual
tiene una estructura inductiva: a) complejidad de los casos base y b) complejidad de los casos
progresivos. Los casos base detienen la recursividad, mientras los casos progresivos la
reactivan.

complejidad de los casos base


T ( n) =
complejidad de los casos progresivos

si n corresponde a los casos base


si n corresponde a los casos progresivos

Siguiendo con el ejemplo del Factorial, ahora se analiza el desempeo del algoritmo
recursivo correspondiente.
Algoritmo Factorial (n)
Entradas: un nmero entero n
Salidas: un nmero entero correspondiente al factorial de n
1 si n = 0 entonces
//caso base
2
Factorial 1
3 sino
// caso progresivo
4
Factorial n*Factorial(n-1)

Instituto Tecnolgico de Ciudad Madero

Dra. Laura Cruz Reyes


Captulo 3 Complejidad de algoritmos recursivos

Unidad I COMPLEJIDAD DE ALGORITMOS

Si la operacin bsica es el nmero de multiplicaciones, entonces la recurrencia que mide el


desempeo de algoritmo Factorial se obtiene identificando sus casos y escribiendo las
reglas que determinan cada caso y las funciones de desempeo correspondientes. En el caso
base (n=0) no se realiza ninguna multiplicacin y en el caso progresivo (n>0) se realiza una
multiplicacin ms las multiplicaciones que el algoritmo ejecuta al ser llamado recursivamente
con un valor de n-1, este ltimo calculo se denota con T(n-1).

0
T ( n) =
1 + T (n 1)

si n = 0 (caso base)
si n > 0 (caso progresivo)

Antes se expandi la recurrencia F(n) para determinar el factorial de 4, ahora se expande la


recurrencia T(n) para calcular el nmero de multiplicaciones.

T(4) = 1 + T(3)=4
T(3) = 1 + T(2)=3
T(2) = 1 + T(1)=2
T(1) = 1 + T(0)=1
T(0) = 0
T(4) = 1 + 1 +1 +1 = 4
Se puede observar que para calcular el factorial de 4, el algoritmo realiza cuatro
multiplicaciones: Factorial(4)=43211. Este nmero de multiplicaciones coincide con
el obtenido por la recurrencia T(4)=4.

3.2.1 Recurrencia de peor caso del algoritmo de bsqueda secuencial recursivo


Una versin ineficiente del algoritmo de bsqueda secuencial es su implementacin recursiva. A
pesar de sus limitaciones, esta versin es sencilla y simplifica la introduccin de los casos de un
problema al anlisis de algoritmos recursivos.
Algoritmo busquedaSecRec(E,p,u,k)
Entradas: Arreglo E, e ndices p y u que delimitan el subarreglo
ordenar contenido en E[p,...,u].
Salidas: E[p,...,u] en orden ascendente.
1 si p>u entonces
//caso base de fracaso
2
respuesta = -1
3 sino si (E[p]=k) entonces
//caso base de xito
4
respuesta p
5
sino
6
respuesta busquedaSecRec(E,p+1,u,k)//caso progresivo
7 devolver respuesta

El peor desempeo del algoritmo busquedaSecRec sucede cuando la bsqueda fracasa.


Este comportamiento se puede identificar fcilmente en el algoritmo. Primero la recursividad se
activa varias veces porque la llave k no ha sido encontrada (caso progresivo). Finalmente el
algoritmo se detiene cuando no existen ms datos para analizar (caso base de fracaso). A
continuacin se detalla el anlisis del peor caso.

Instituto Tecnolgico de Ciudad Madero

Dra. Laura Cruz Reyes


Captulo 3 Complejidad de algoritmos recursivos

Unidad I COMPLEJIDAD DE ALGORITMOS

a) Caso base de fracaso: p>u


En el paso 1, cuando todos los elementos de E ya han sido analizados, el ndice p rebasa el
valor del ndice u.

0 1 2 3 4 5

En estas condiciones el algoritmo se detiene porque no tuvo xito, as que el nmero de


comparaciones es cero porque no se tienen elementos en el segmento de bsqueda ya que
p>u. Es importante notar que la condicin si p>u equivale a la condicin si n=0.

W(n)paso 1 = 0,

si n=0

b) Caso progresivo (invocacin de recursividad): pu y E[p]k


Despus que en el paso 1 se encontr que pu, en el paso 3 se realiza una comparacin no
exitosa ya que E[p]k. En este paso el subarreglo s tiene elementos ya que pu. De igual
manera la condicin si pu equivale a la condicin si n>0.

W(n)paso 3 = 1,

n>0

En el paso 6 se ejecuta una invocacin recursiva con un subarreglo disminuido en una


unidad; en este paso el subarreglo tambin tiene elementos.

W(n)paso 6 = W(n-1),

n>0

c) Recurrencia del peor caso


Considerando todos los casos involucrados (caso base de fracaso y caso progresivo), la
recurrencia del peor caso queda como sigue:

0
W (n) =
1 + W (n 1)

si n = 0
si n > 0

Intuitivamente se puede observar que en cada llamada recursiva se realiza una


comparacin. Dado que se realizan n invocaciones al algoritmo, la solucin de la recurrencia
es n.

W (n) = 1 + 1 + 1 + 1 + ... + 1 = n = (n)

Instituto Tecnolgico de Ciudad Madero

Dra. Laura Cruz Reyes


Captulo 3 Complejidad de algoritmos recursivos

Unidad I COMPLEJIDAD DE ALGORITMOS

3.2.2 Recurrencia de peor caso del algoritmo de bsqueda binaria


Un algoritmo muy popular es el de bsqueda binaria. La aplicacin de este algoritmo
requiere un ordenamiento previo de los datos.
Algoritmo bsquedaBinaria (E,p,u,k)
Entradas: Arreglo E, e ndices p y u que
ordenar contenido en E[p,...,u].
Salidas: E[p,...,u] en orden ascendente.
1
2
3
4
5
6
7
8
9
10

delimitan

el

subarreglo

si (p>u)entonces
//caso base de fracaso
devolver -1
medio (p + u)/2
si k = E(medio) entonces
//caso base de xito
ndice medio
sino si (k < E[medio]) entonces
ndice bsquedaBinaria(E,p,medio1,k) //caso progresivo
sino
ndice bsquedaBinaria(E,medio+1,u,k) //caso progresivo
devolver ndice

El peor desempeo del algoritmo bsquedaBinaria sucede cuando la bsqueda fracasa.


Primero la recursividad se activa varias veces porque la llave k no ha sido encontrada en la
posicin media (caso recursivo). Finalmente el algoritmo se detiene cuando no existen ms
datos para analizar (caso base de fracaso).

a) Caso base de fracaso : p > u


Cuando todos los elementos de E ya han sido analizados, el valor de p rebasa al de u; as
que el nmero de elementos del segmento de bsquedas es cero.

W(n)paso 1 = 0,

si n=0

b) Caso progresivo (invocacin de recursividad): pu y E[medio]k


En el paso 5 del algoritmo se realiza una comparacin no exitosa.

W(n)paso 5 = 1,

si n>0

En el paso 7 se realiza una comparacin para ubicar la siguiente bsqueda.

W(n)paso 7 = 1, si n>0
En las lneas 8 y 9 las invocaciones recursivas se realizan con subarreglos de diferentes
tamaos. Cuando n es par: el segmento izquierdo es n/2 y el derecho es (n/2)-1. Cuando n
es impar: los segmentos izquierdo y derecho son (n-1)/2. El mayor de cada tipo de tamao
es n/2 y (n-1)/2. Ambos tamaos mximos quedan expresados con n/2.

W(n)paso 8 o paso 9 = W(n/2),

si n>0

Instituto Tecnolgico de Ciudad Madero

Dra. Laura Cruz Reyes


Captulo 3 Complejidad de algoritmos recursivos

Unidad I COMPLEJIDAD DE ALGORITMOS

c) Recurrencia del peor caso


La siguiente recurrencia expresa el nmero de comparaciones de clave en el peor caso:

W (n) =
n
2 + W 2

si n = 0
si n > 0

3.3 Ecuaciones de recurrencia comunes


Muchos algoritmos clsicos han sido diseados en base a dos tcnicas que permiten plantear la
solucin de un problema en trminos de varios subproblemas de menor dimensin.

3.3.1 Algoritmos basados en divide-y-vencers


Usando la tcnica de divide-y-vencers, si un problema es demasiado grande para resolverlo
de una vez, se descompone en varias partes ms fciles de resolver. Con ms formalidad, dado
un problema a resolver planteado en trminos de una entrada de tamao n, la tcnica de divide
la entrada en b subproblemas, 1<b< n. Estos subproblemas se resuelven independientemente y
despus se combinan sus soluciones parciales para obtener la solucin del problema original.
En la funcin de recurrencia para divide-y-vencers, n es el tamao del problema principal,
b son los subproblemas (1<b< n), cada uno de tamao n/c (1<c< n). Para dividir el problema en
subproblemas y combinar las soluciones de los subproblemas existe cierto costo no recursivo
que se expresan en f(n).

T(n) = b T( n/c ) + f(n)


Nmero de subproblemas
(factor de ramificacin)

Costo de dividir en subproblemas y combinar las soluciones


Costo de resolver un subproblema obtenido por divisin

El algoritmo de ordenamiento mergeSort es un ejemplo de la aplicacin de la tcnica de


divide-y-venceras.
Algoritmo mergeSort (E, p, u)
Entradas: Arreglo E, e ndices p y u que delimitan el subarreglo a
ordenar contenido en E[p,...,u].
Salidas: E[p,...,u] en orden ascendente.
1
si (p < u) entonces
//caso progresivo
2
m (p + u)/2
3
mergeSort(E, p, m)
4
mergeSort(E, m + 1, u)
5
fusionar(E, p, m, u)

El caso base del algoritmo mergeSort no est explicito en el algoritmo, pero sucede
cuando p u, e implica que no se realizan comparaciones cuando el arreglo es de tamao 1.

W (n) paso implicito = 0 ,

si n=1

Instituto Tecnolgico de Ciudad Madero

Dra. Laura Cruz Reyes


Captulo 3 Complejidad de algoritmos recursivos

Unidad I COMPLEJIDAD DE ALGORITMOS

Cuando el arreglo es de tamao mayor de n, el nmero de comparaciones se puede derivar


aplicando la frmula para los algoritmos de tipo divide-y-venceras.

W (n) = 2W n + (n 1) ,
2
Comparaciones para ordenar por
separado las parte derecha e izquierda
que son de tamao n/2 (b=2, c=2).

si n>1
Comparaciones para fusionar dos subarreglos
ordenados de tamao n/2. En el peor caso se toma
alternadamente un elemento de cada subarreglo,
requiriendose n-1 comparaciones ( f(n) = n-1 ).

Reuniendo en una sola expresin los casos base y recursivo, la complejidad del algoritmo
mergeSort en el peor caso es como sigue.

si n = 0
0

W (n) =
n
2W 2 + (n 1) si n > 0

3.3.2 Algoritmos basados en recorta-y-vencers


El problema principal de tamao n se puede recortar a b subproblemas (1<b< n), cada uno de
tamao n-c (1<c< n), con costo no recursivo f(n) debido a la tarea de recortar y combinar.

T(n) = b T(n-c) + f(n)


Nmero de subproblemas
(factor de ramificacin)

Costo de recortar en subproblemas y combinar soluciones


Costo de resolver un problema obtenido por recorte

Si los subproblemas son de distinto tamao se pueden obtener lmites asintticos que
acotan el desempeo.
Cota superior expresada con O(n): utilizando T(n) b T(n cmax) + f(n)
Cota inferior expresada con (n): utilizando T(n) b T(n cmin) + f(n)
3.4 Solucin de recurrencias mediante el mtodo iterativo
Este mtodo convierte la funcin de recurrencia en una sumatoria que posteriormente se evala
para obtener un lmite de la funcin. De manera general el mtodo iterativo consiste en: a)
Expansin de la recurrencia para identificar patrones de regularidad y expresarlos como sumas
de trminos dependientes slo de n y las condiciones iniciales y, b) Evaluacin de la sumatoria.
3.4.1 Pasos del mtodo iterativo
La siguiente secuencia detallada de pasos permite determinar la complejidad (O(n), (n), o

(n)) de un algoritmo recursivo.


Paso 1. Determinar una funcin T(n) que represente el nmero de operaciones bsicas
efectuadas por el algoritmo para el tamao base y para los casos definidos por recursividad

Instituto Tecnolgico de Ciudad Madero

Dra. Laura Cruz Reyes


Captulo 3 Complejidad de algoritmos recursivos

Unidad I COMPLEJIDAD DE ALGORITMOS

fuera de la base. Para simplificar la explicacin del mtodo usaremos la siguiente estructura de
recurrencia que genera en cada nivel b problemas y denotaremos con ni al tamao del
problema en el nivel de recurrencia i.

c
T (ni ) =
bT (ni +1 ) + f (ni )

si ni corresponde al caso base


si ni corresponde al caso progresivo

Paso 2. Evaluar la funcin T(n) del caso progresivo con un conjunto pequeo de valores
consecutivos de n.
T(n0) = f(n0) + bT(n1)
T(n1) = f(n1) + bT(n2)
T(n2) = f(n2) + bT(n3)
T(n3) = f(n3) + bT(n4)
T(n4) = f(n4) + bT(n4)
Paso 3. Sustituir los resultados del punto anterior en cada expresin antecesora.
T(n0) = f(n0) + bf(n1) +b2 f(n2) + b3f(n3) + b4 T(n4)
Paso 4. Identificar un patrn con el cual pueda generalizarse la representacin de los trminos
del desarrollo.
Paso 5. Expresar en notacin de sumatorias el patrn identificado, destacando dos partes en la
expresin: un conjunto de trminos inductivos y un trmino llamado de base o de paro,
referenciado por m.
Paso 6. Determinar un valor de m para el cual se satisfaga o al menos se aproxime a la igualdad

tamao de problema

del trmino

referenciado por m

tamao de problema

que detiene la
=

recursividad

Paso 7. Sustituir m en la expresin de sumatoria obtenida en el paso 5.


Paso 8. Resolver la sumatoria con una expresin equivalente o aproximada cuya nica variable
independiente es n. Para esta tarea puede ser de gran ayuda utilizar programas
computacionales como Derive.

3.4.2 Ejemplos de recurrencias resueltas con el mtodo iterativo


La siguiente recurrencia se utilizar para ilustrar el mtodo iterativo.

n
+ n n >1
2T
T ( n ) = 2

1
n =1

Instituto Tecnolgico de Ciudad Madero

Dra. Laura Cruz Reyes


Captulo 3 Complejidad de algoritmos recursivos

Unidad I COMPLEJIDAD DE ALGORITMOS

Primero se generan cuatro recurrencias para tamaos de problema consecutivos.

( 2)
n
T ( n ) = + 2T ( n )
2
4
2
n
T ( n ) = + 2T ( n )
4
8
4
n
T ( n ) = + 2T ( n )
8
16
8
T (n) = n + 2T n

Enseguida se usan las recurrencias de anteriores para hacer la expansin de la recurrencia


original.

( )

T (n) = n + 2 n + 2 2T n
2
4
T ( n ) = n + 2 n + 2 2 n + 2 2 2T n
2
4
8
T ( n ) = n + 2 n + 2 2 n + 2 2 2 n + 2 2 2 2T n
2
4
8
16
T ( n ) = n + 21 n

21

+ 22 n

22

( )

+ 23 n

23

( )

( 2)

+ 24 T n

Dado que se desconoce en cuntos trminos la funcin T(n) debe ser expandida para
alcanzar el caso base, se usar el ndice m para hacer referencia al trmino correspondiente a
la condicin de paro.

T (n) = n + 21 n 1 + 22 n 2 + 23 n 3 + ... + trmino m 1 + [ trmino m ]


2
2
2

Se forma una sumatoria cuyo patrn de regularidad es 2i n / 2i

con i= 0m-1. Posterior a

esta sumatoria sigue el trmino de paro, cuyo coeficiente y tamao de problema siguen un
patrn similar con i=m.

T (n) = n + 21 n 1 + 22 n 2 + 23 n 3 + ... + 2m 1 n m 1 + 2m T n m 1
2
2
2
2
2

m 1

T ( n ) = 2i n
i =0

2m 1

)+2 T (n2 )
m

m 1

La sumatoria se simplifica al considerar que el ltimo termino corresponde al caso base con

n=1 y T(1)=1.
m 1

( 2)

T ( n ) = 2i n
i =0

+ 2m T n

m 1

m 1

m 1

i =0

i =0

= n + 2m T (1) = n + 2m

Encontramos el valor de m igualando las dos condiciones de paro.

Instituto Tecnolgico de Ciudad Madero

Dra. Laura Cruz Reyes


Captulo 3 Complejidad de algoritmos recursivos

Unidad I COMPLEJIDAD DE ALGORITMOS

( 2 ) = T (1)

T n

=1
2m
2m = n
n

log 2 (2m ) = log 2 (n)


m = log 2 (n)
La solucin de la recurrencia indica que el algoritmo tiene un crecimiento n-logartmico.

T ( n) =

log 2 ( n ) 1

n + 2log n

i =0

T (n) = n log n + n log 2 = n log n + n = (n log n)


Enseguida, un segundo ejemplo para clarificar el mtodo iterativo.

n
+ n n >1
3T
T ( n ) = 4

n =1
(1)

Primero se generan recurrencias para diferentes tamaos de problema.

T (n) = n + 3T n
4
n
T n = + 3T n
4
16
4
n
T n = + 3T n
16 16
64
n

T n =
+ 3T n
64 64
256

(
(
(

)
)

(
(

Enseguida se usan las recurrencias anteriores para hacer la expansin de la recurrencia


original.

T (n) = n + 3T n
4
3n
T (n) = n + + 9T n
16
4

)
)

3n 9n
+
+ 27T n
64
4 16
3n 9n 27 n

+
+ 81T n
T ( n) = n + +
256
4 16 64

T ( n) = n +

Instituto Tecnolgico de Ciudad Madero

Dra. Laura Cruz Reyes


Captulo 3 Complejidad de algoritmos recursivos

Unidad I COMPLEJIDAD DE ALGORITMOS

Dado que se desconoce en cuntos trminos la funcin T(n) debe ser expandida para
alcanzar el caso base, se usar el ndice m para hacer referencia al trmino correspondiente a
la condicin de paro.

3n 9n 27 n

T ( n) = n + +
+
+ ... + [ trmino referenciado por m ]
4 16 64

Antes de la ltima llamada recursiva se forma una sumatoria cuyo patrn de regularidad
(trmino general) es 3i n / 4i con i= 0m-1. Despus sigue el trmino asociado a la
condicin de paro, cuyo coeficiente y tamao de problema siguen un patrn similar con i=m.

3n 9n 27 n

T ( n) = n + + +
+ ...+ 3m 1 n m 1 + 3m T n m
4

4
4 16 64

m 1

T (n) = 3i n i + 3m T n m
4
4
i =0

El ltimo trmino de la sumatoria se simplifica ya que ste corresponde al caso base con n=1
y T(1)=(1).
m 1

T (n) = 3i n i + 3m T (1)
4
i =0
Usando el lmite n

n m , encontramos el valor de m que hace referencia al ltimo


4
4m

trmino de la sumatoria.

) ( )

( )

T n m T n m , como T n m = T (1), entonces T n m T (1)


4
4
4
4
n m 1
4
m
4 n
log 4 (4m ) log 4 (n)
m log 4 (n)
El valor de m se sustituye en la recurrencia expandida.

T ( n)

log 4 ( n ) 1

3i n i + 3log 4 ( n ) (1)
4

log 4 ( n ) 1

3i n i + ( 3log4 ( n ) )
4

log 4 ( n ) 1

3i n i + ( n log4 (3) )
4

i =0

T ( n)

i =0

T ( n)

i =0

Instituto Tecnolgico de Ciudad Madero

Dra. Laura Cruz Reyes


Captulo 3 Complejidad de algoritmos recursivos

Unidad I COMPLEJIDAD DE ALGORITMOS

El lmite superior de la sumatoria de T(n) se puede sustituir por infinito para utilizar una serie
geomtrica infinita.

i =0

=1
con r = 3/4
1 r

T (n) n (3 / 4)i + ( n log 4 (3) )


i =0

1
log 4 (3)
T ( n) n
)
+ (n
1 3 / 4
T (n) 4n + ( n log4 (3) )
T ( n) = O ( n)
Un lmite superior ms ajustado para T(n) se obtiene con una serie geomtrica finita.
k

ar

i =0

= a ( (r k +1 1) /(r 1) ) .

Con las series geomtricas decrecientes, la suma total es a lo ms un factor constante mayor
que el primer trmino. Por lo tanto en la solucin prevalece el primer trmino n que es menor
que 4n por un factor de 4.

n (3 / 4)i = n +
i =0

3n 9n 27 n
+ +
+ ... = 4n
4 16 64

3.5 Solucin de recurrencias mediante el mtodo de rbol de recursin


Los rboles de recursin son una herramienta visual para analizar el costo de procedimientos
recursivos asociados a una estructura de rbol, por ejemplo los algoritmos de divide-y-venceras.
3.5.1 Descripcin del mtodo de rbol de recursin
Se construye el rbol para organizar por niveles las operaciones algebraicas necesarias para
resolver la recurrencia. Cada nodo del rbol tiene una estructura de dos componentes: la
funcin de costos y el costo no-recursivo.
Los nodos nodos
intermedios se
expanden con los
casos progresivo

Los nodos
hoja son los
casos base.

Funcin de costo

Costo no-recursivo

Instituto Tecnolgico de Ciudad Madero

Dra. Laura Cruz Reyes


Captulo 3 Complejidad de algoritmos recursivos

Unidad I COMPLEJIDAD DE ALGORITMOS

3.5.2 Ejemplos de recurrencias resueltas con el mtodo de rbol de recursin


El siguiente ejemplo ilustra el mtodo de solucin de recurrencias basado en rbol de recursin.

2T (n / 2) + n 2
T ( n) =
0

n >1
n =1

Primero se construye el rbol de recurrencia determinando para cada nodo la funcin de


costos y el costo no recursivo. Para cada nivel se calcula el costo total.
Tnivel0= n2

n2

T(n)
log2(n)

T(n/2)

T(n/4)

(n/4)2

(n/2)2

T(n/4)

T(n/2)

(n/4)2

T(n/4)

(n/4)2

Tnivel1= 2(n/2)2=n2/2

(n/2)2

T(n/4)

Tnivel2= 4(n/4)2=n2/4

(n/4)2

T(1)

Tnivelm= 0

Un anlisis visual del rbol revela que en cada nivel el nmero de subproblemas aumenta en
potencias de dos.

( 2 ) ( 2 ) ( 2 ) ... ( 2 )
0

En cada nivel el tamao de los problemas disminuye en potencias de dos.

1 1 1
1
0 n 1 n 2 n ... m n
2 2 2
2
En cada nivel la complejidad algortmica total incrementa en potencias de dos. Es importante
m
m
observar que en el ltimo nivel se tienen 2 nodos y cada nodo es de tamao (1/2 )n.

1 2 1 2 1 2
1
m
0 n 1 n 2 n ... ( 2 ) T m
2
2
2

Usando el patrn de complejidad y las condiciones de terminacin, la recurrencia se expresa


como una sumatoria.

1
1
1

1
T (n) = n 2 + n 2 + n 2 + ... + m 1 n 2 + 2m T m n
2
4
2

2
m 1
1
1
1
1

T (n) = n 2 + n 2 + n 2 + ... + m 1 n 2 + 0 = n 2 i + 0
2
4
2

i =0 2

Instituto Tecnolgico de Ciudad Madero

Dra. Laura Cruz Reyes


Captulo 3 Complejidad de algoritmos recursivos

Unidad I COMPLEJIDAD DE ALGORITMOS

El valor de m se determina igualando las dos expresiones del caso base.

1
T m n = T (1)
2
1
n = 1; 2m = n; log 2m = log n
m
2
m = log n
Para la solucin de T(n) se usa la serie geomtrica con r=1/2.
k

ar

i =0

2
i =0

= a ( (r k +1 1) /(r 1) )

= 2

1
2k

La solucin de la recurrencia T(n) revela que el algoritmo tiene una velocidad de crecimiento
cuadrtica

T ( n) = n 2

(log n ) 1

i =0

1
1
2
= n 2 2 (log n ) 1 = n 2 2 = 2n 2 2n
i
2

2
n

T ( n ) = ( n 2 )
Con un segundo ejemplo se ilustra el mtodo de rbol de recursin.

T (n / 3) + T (2n / 3) + n n > 1
T ( n) =
n =1
0
Primero se construye el rbol de recurrencia determinando para cada nodo la funcin de
costos y el costo no recursivo. Para cada nivel se calcula el costo total.
T(n)

Tnivel0= n

log3/2(n)

T(n/3)

T(n/9)

(n/9)

(n/3)

T(2n/9)

T(2n/3)

(2n/9)

T(2n/9)

(2n/9)

Tnivel1= (n/3)+ (2n/3)=n

(2n/3)

T(4n/9)

Tnivel2= (n/9)++ (4n/9) =n

(4n/9)

T(1)

Tnivelm= 0

Instituto Tecnolgico de Ciudad Madero

Dra. Laura Cruz Reyes


Captulo 3 Complejidad de algoritmos recursivos

Unidad I COMPLEJIDAD DE ALGORITMOS

En cada nivel el nmero de subproblemas aumenta en potencias de dos.

( 2 ) ( 2 ) ( 2 ) ... ( 2 )
0

En cada nivel el tamao ms grande de problema disminuye por un factor de (2/3) .


0

2
2
2
2
n n n ...
3
3
3
3

m 1

2
n n
3

En cada nivel la complejidad algortmica permanece constante.

2 m
n
3

( n ) ( n ) ( n ) ... ( 2m ) T

Usando el patrn de complejidad y las condiciones de terminacin, la recurrencia se expresa


como una sumatoria. Dado que esta sumatoria corresponde a la trayectoria ms larga
(subproblemas mayores), se obtiene una cota superior de las trayectorias restantes.

2 m
T (n) n + n + n + ... + n + ( 2m ) T n
3

m 1

T ( n) ( n) + 0
i =0

El valor de m se determina igualando las dos expresiones que representan la condicin de


paro.
m

2
T n = T (1)
3
m

2
n =1
3
m

3
=n
2
m

3
log 3/ 2 = log 3/ 2 n
2
m = log 3/ 2 n
Para la solucin de T(n) se usa una diferencia de lmites.

Instituto Tecnolgico de Ciudad Madero

Dra. Laura Cruz Reyes


Captulo 3 Complejidad de algoritmos recursivos

Unidad I COMPLEJIDAD DE ALGORITMOS


m 1

T ( n) ( n)
i =0

T ( n)

log3 / 2 ( n ) 1

( n)

i =0

T ( n) n

log3 / 2 ( n ) 1

(1)

i =0

T (n) n(log 3/ 2 (n) 1 + 1)


T (n) n log 3/ 2 (n)
T (n) = O(n log n)
Con un tercer ejemplo se ilustra el mtodo de rbol de recursin.

2T (n / 2) + n n > 1
T ( n) =
n =1
0
Primero se construye el rbol de recurrencia determinando para cada nodo la funcin de
costos y el costo no recursivo acordes al nivel de recursividad que le corresponda. Para cada
nivel se calcula el costo total.

T(n)

Tnivel0= n

log2(n)
T(n/2)

T(n/4)

(n/4)

(n/2)

T(n/4)

T(n/2)

(n/4)

(n/4)

T(n/4)

Tnivel1= (n/2)+ (n/2)=n

(n/2)

T(n/4)

(n/4)

T(1) 0

Tnivel2= (n/4)++ (n/4) =n

Tnivelm= 0

En cada nivel el nmero de subproblemas aumenta en potencias de dos.

( 2 ) ( 2 ) ( 2 ) ... ( 2 )
0

Estableciendo el supuesto que en todos los niveles del rbol n es par, en cada nivel el tamao
del problema disminuye en potencias de dos.

1
0
2

1 1
n 1 n 2
2 2

1
n ... m

Instituto Tecnolgico de Ciudad Madero

Dra. Laura Cruz Reyes


Captulo 3 Complejidad de algoritmos recursivos

Unidad I COMPLEJIDAD DE ALGORITMOS

En cada nivel la complejidad algortmica permanece constante.

( n ) ( n ) ( n ) ... ( 2m ) T

1
n
m
2

Usando el patrn de complejidad y las condiciones de terminacin, la recurrencia se expresa


como una sumatoria.

1
T (n) = n + n + n + ... + n + ( 2m ) T m
2

m 1
n = (n) + 0
i =0

El valor de m se determina igualando las dos expresiones que representan la condicin de


paro.

n
T m =1
2
n
=1
2m
2m = n
log 2 ( 2m ) = log 2 n
m = log 2 n
Para la solucin de T(n) se usa una diferencia de lmites.

T (n) = n + n + n + ... + n + 0
m 1

log 2 ( n ) 1

i =0

i =0

T ( n) = ( n) = T ( n) =

( n) = T ( n) = n

log 2 ( n ) 1

(1)

i =0

T (n) = n log 2 (n)


T (n) = (n log n)

3.6 Solucin de recurrencias mediante el mtodo maestro


El mtodo maestro es una receta para resolver recurrencias derivadas de aplicar la tcnica de
divide-y-vencers.
T(n) = b T( n/c ) + f(n)

3.6.1

Descripcin del mtodo maestro

En la aplicacin del mtodo se puede omitir el piso y techo del tamao del problema ya que no
afecta a la solucin de la recurrencia porque sta se expresa con funciones asintticas.

Instituto Tecnolgico de Ciudad Madero

Dra. Laura Cruz Reyes


Captulo 3 Complejidad de algoritmos recursivos

Unidad I COMPLEJIDAD DE ALGORITMOS

n / c n / c n / c
La solucin de una recurrencia est sujeta al caso que le corresponda. Se pueden probar
cada uno de los casos, o usar el rbol de recursividad para identificar la serie que mejor lo
describe.
Caso 1: La complejidad es una serie geomtrica creciente

si f (n) = (n logc b ) para alguna constante > 0


entonces T ( n) = ( n

logc b

Caso 2: La complejidad es constante en cada nivel


si f ( n) = ( n

log c b

entonces T ( n) = ( n

log c b

lg n)

Caso 3: La complejidad es una serie geomtrica decreciente

si f (n) = (n logc b + ) para alguna constante > 0, y


si bf(n/c)cf(n) para alguna constante c<1 y para n suficientemente grande,
entonces T (n) = ( f (n))
La segunda condicin prueba que bf(n/c), la complejidad del nivel 1, disminuye o se
mantiene con respecto a cf(n), que es la complejidad del nivel 0.

3.6.2 Interpretacin del mtodo maestro


En los tres casos se compara f(n), que es el primer trmino de la sumatoria expandida de la
log b
recurrencia original, con n c , que es el ltimo:

Recurrencia
T (n) = bT ( n / c ) + f (n)
Sumatoria
T (n) = f (n) + b f ( n / c ) + ... + n logc b
log b

a) En el caso 1 la funcin f(n) es polinomialmente ms pequea que n c . Esto es, f(n) es

asintticamente ms pequea por un factor de n . Esto sucede en las series geomtricas


crecientes.
log b
b) En el caso 2 la funcin f(n) es asintticamente equivalente a n c , esto sucede en las series
constantes.

Instituto Tecnolgico de Ciudad Madero


Unidad I COMPLEJIDAD DE ALGORITMOS

Dra. Laura Cruz Reyes


Captulo 3 Complejidad de algoritmos recursivos
log b

c) En el caso 3 la funcin f(n) es polinomialmente ms grande que n c por un factor de n .

Esto es, f(n) es asintticamente ms grande por un factor de n . esto sucede en las series
geometricas decrecientes.
La superioridad de una funcin h(n) sobre otra g(n) se dice que es polinomial, si es
significativa. Esto es, existe una constante >0 tal que g(n) es asintticamente ms pequea

que h(n) por un factor n .

n g ( n) h( n)
En el caso 1:

h(n) = n logc b , g (n) = f (n)


n f (n) n logc b
f (n) n logc b
En el caso 3:

h(n) = f (n), g (n) = n logc b


n n logc b f (n)
f (n) n logc b +
Las recurrencias en las que f(n) es superior o inferior por un factor que no es polinomial, no
deben ser resueltas con el mtodo maestro.

3.6.3 Ejemplos de recurrencias resueltas con el mtodo maestro


El siguiente ejemplo ilustra el primer caso correspondiente a una serie geomtrica creciente.

9T (n / 3) + n n > 1
T ( n) =
n =1
1
De la frmula general de divide-y-vencers:
T(n) = b T( n/c ) + f(n)
b=9, c=3, f(n) =n,
Para determinar que la recurrencia corresponde al caso 1 del Teorema Maestro, sea:

f ( n) = n
g (n) = n logc b = n log3 9 = n 2
Se demuestra que f(n) = O(g(n)):

Instituto Tecnolgico de Ciudad Madero

Dra. Laura Cruz Reyes


Captulo 3 Complejidad de algoritmos recursivos

Unidad I COMPLEJIDAD DE ALGORITMOS

f ( n)
n
lim
= lim

x g ( n)
x n 2

1
n
lim 2 = 1 = 1 si = 1
x n

n
1
n
lim 2 = 1 = 0 si 0> < 1
x n

n
f (n) = (n logc b ) para > 0
Por lo anterior, entonces el ltimo trmino de la recurrencia es el dominante,

T (n) = (n logc b ) = (n log3 9 ) = (n 2 )


Alternativamente se puede resolver la recurrencia mediante la construccin del rbol de
recursin.
T(n)

Tnivel0= n

log3(n)
.

(n/3)

T(n/3)

T(n/3)

.
(n/9)

T(n/9)

.
(n/9)

T(n/9)

Tnivel1= (n/3)+ +(n/3)=9n/3=3n

(n/3)

T(n/9)

(n/9)

(n/9)

T(n/9)
.

T(1) 1

Se obtiene el patrn del tamao de problema: n/3


0

m 1

Tnivel2= (n/9)++ (n/9) =81n/3=9n


Tnivelm= 1++1=3mn=3log3nn=n2

1
1
1
1
1
n n n ... n n
3
3
3
3
3
En la profundidad i=m del rbol el tamao del problema es 1
n
=1
3m
3m = n
log 3 ( 2m ) = log 3 n
m = log 3 n
i

Se obtiene el patrn de complejidad 3 n, que da lugar a una serie creciente donde el ltimo
2
trmino n es el dominante.

Instituto Tecnolgico de Ciudad Madero


Unidad I COMPLEJIDAD DE ALGORITMOS

Dra. Laura Cruz Reyes


Captulo 3 Complejidad de algoritmos recursivos

T (n) = n + 3n + 9n + ... + 3m 1 n + 0
T (n) = n + 3n + 9n + ... + 3(log3 n ) 1 n
T ( n) = n

(log3 n ) 1

(3i )

i =0
k

Usando la serie

ar

i =0

= a ( (r k +1 1) /(r 1) ) , se resuelve la recurrencia.

(3log3 ( n ) 1) n(n 1)
n2 n
T ( n) = n
==
=
3 1
2
2

T ( n ) = ( n 2 )
El siguiente ejemplo ilustra el segundo caso correspondiente a una serie constante.

T (2n / 3) + 1 n > 1
T ( n) =
n =1
0
De la frmula general de divide-y-vencers:

T(n) = b T( n/c ) + f(n),


b=1, c=3/2, f(n) =1,
Para determinar que la recurrencia corresponde al caso 2 del Teorema Maestro, sea,

f ( n) = 1
g (n) = n logc b = n log3 / 2 1 = n 0 = 1
Se demuestra que f(n) = (g(n)):

f ( n)
1
lim
= lim
=1
x g ( n)
x 1

f (n) = (n logc b )
Como f ( n) = ( n
ltimo trmino,

log c b

) , entonces todos los lgn trminos de la recurrencia son iguales al

T (n) = (n logc b lg n) = (n log3 / 2 1 lg n) = (lg n)


Alternativamente se puede resolver la recurrencia mediante la construccin del rbol de
recursin.

Instituto Tecnolgico de Ciudad Madero

Dra. Laura Cruz Reyes


Captulo 3 Complejidad de algoritmos recursivos

Unidad I COMPLEJIDAD DE ALGORITMOS

T(n)

Tnivel0= 1

T(2n/3)

Tnivel1= 1

T(4n/9)

Tnivel2= 1

T(1)

Tnivelm= 1

log3/2(n)

Se obtiene el patrn del tamao de problema: (2/3)in.


0

2
2
2
1
n n n ...
3
3
3
3

m 1

2
n n =1
3

En la profundidad i=m del rbol, el tamao del problema es 1.


m

2
n =1
3
m

3
=n
2
m

3
log 3/ 2 = log 3/ 2 n
2
m = log 3/ 2 n
Se obtiene como patrn de complejidad una constante que prevalece hasta la profundidad del
rbol.

T (n) = 1 + 1 + 1 + ... + 1
T ( n) =

log3 / 2 n

1
i =0

T (n) = log 3/ 2 (n) + 1


T (n) = (lg n)
El siguiente ejemplo ilustra el tercer caso correspondiente a una serie geomtrica decreciente.

3T (n / 4) + n lg n n > 0
T ( n) =
n=0
0

Instituto Tecnolgico de Ciudad Madero

Dra. Laura Cruz Reyes


Captulo 3 Complejidad de algoritmos recursivos

Unidad I COMPLEJIDAD DE ALGORITMOS

De la frmula general de divide-y-venceras:


T(n) = b T( n/c ) + f(n),
b=3, c=4, f(n) =nlgn.
Para determinar que la recurrencia corresponde al caso 3 del Teorema Maestro, sea

f (n) = n lg n
g (n) = n logc b + = n log 4 3+
Se demuestra que f(n) = (g(n))

f ( n)
n lg n
lim
= lim

x g ( n)
x n log 4 3+

n lg n
lim 0.793 = lim lg n =
x n
n x

si = 0.207

n lg n
lim 0.793 = si 0< 0.207
x n
n

f (n) = (n logc b + ) para > 0


Adems, se demuestra que bf(n/c)cf(n) para alguna constante c<1 y para n
suficientemente grande

3
n n
3 lg cn lg n si c=
4
4 4
3
n 3
n lg n lg n
4
4 4
bf (n / c) c f (n) para c< 1
Por lo anterior,

T (n) = ( f (n)) = (n lg n)
3.7 Solucin de recurrencias mediante el mtodo de substitucin
Se usa cuando las ecuaciones son no lineales. Mediante induccin matemtica se prueba que
una solucin adivinada para T(n) es correcta en condiciones lmite.
3.7.1 Pasos del mtodo de substitucin
Paso1: Adivinacin

Instituto Tecnolgico de Ciudad Madero


Unidad I COMPLEJIDAD DE ALGORITMOS

Dra. Laura Cruz Reyes


Captulo 3 Complejidad de algoritmos recursivos

Se conjetura que la solucin de T(n) pertenece a algn orden de O(f(n)).


Paso2: Prueba inductiva
a) Hiptesis: La funcin adivinada se establece como hiptesis inductiva

T(n) cf(n) para una c>0


b) Caso Base: Para n pequea se prueba T(n) cf(n).
La hiptesis inductiva se prueba con el tamao de problema ms pequeo. Como la
solucin adivinada se expresa en notacin asinttica slo basta encontrar una n0, tal que la
hiptesis inductiva se cumpla para cualquier n > n0. El valor de n0 se substituye en la
recurrencia para encontrar su solucin con n pequea. La prueba es correcta si la hiptesis
y la recurrencia coinciden en alguna constante c.
c) Caso General: Suponiendo T(n) cf(n) verdadera demostrar que T(n-1) cf(n-1)
La hiptesis inductiva se prueba con un valor de problema grande. Para ello se asume que
dicha hiptesis es vlida con el tamao anterior kf-1 al del ms grande que es kf. Esta se
substituye en la recurrencia evaluada en kf, y se considera correcta si alcanza la forma
exacta de la hiptesis inductiva.

3.7.2 Ejemplos de recurrencias resueltas con el mtodo de sustitucin


El siguiente ejemplo ilustra el mtodo de sustitucin.

2T ( n / 2 ) + n n > 1
T ( n) =
n =1
1
Paso 1: Adivinacin
Sea T(n) = O(nlgn) la solucin adivinada
Paso 2: Prueba inductiva
a) Como hiptesis inductiva se establece la funcin

T(n) c(nlgn) para una c>0.


b) Para probar que la hiptesis inductiva es vlida con un tamao de problema grande kf =n,
primero se asume que esta hiptesis es valida con un valor kf-1 =n/2 anterior al de kf.
La hiptesis inductiva de la solucin adivinada es:

Instituto Tecnolgico de Ciudad Madero


Unidad I COMPLEJIDAD DE ALGORITMOS

Dra. Laura Cruz Reyes


Captulo 3 Complejidad de algoritmos recursivos

T (n) = O(n log n)


T (n) c(n log n)
La hiptesis inductiva para kf-1 =n/2 queda:

T ( n / 2 ) c n / 2 lg n / 2
La recurrencia original para kf =n es:

T (n) = 2T ( n / 2 ) + n
La hiptesis inductiva que es valida en kf-1 se sustituye en la recurrencia especificada en el
tamao de problema ms grande kf. La recurrencia original, con la sustitucin de la hiptesis
inductiva, queda

T ( n ) 2c n / 2 lg n / 2 + n
T ( n ) cn lg(n / 2) + n

T ( n ) cn lg n cn lg 2 + n
T ( n ) cn lg n cn + n
Para c=1 se encuentra la forma exacta de la hiptesis inductiva:

T ( n ) (1)n lg n (1)n + n
T ( n ) n lg n
c) Se busca un valor pequeo de n para el cual la hiptesis inductiva es vlida.
Para n0 =1, que es el tamao de problema ms pequeo, la hiptesis inductiva queda:

T ( n ) cn lg n
T (1) c(1) lg(1) = 0
La hiptesis es inconsistente con el caso base de la recurrencia ya que no existe una c que
pueda obtener su condicin lmite T(1)=1.
Cuando n0=1 la hiptesis inductiva no se cumple.
Para n0 =2, la hiptesis inductiva queda:

T ( n ) cn lg n
T ( 2 ) c(2) lg(2) = 2c
El valor de n0 =2 se sustituye en la recurrencia:

Instituto Tecnolgico de Ciudad Madero


Unidad I COMPLEJIDAD DE ALGORITMOS

Dra. Laura Cruz Reyes


Captulo 3 Complejidad de algoritmos recursivos

T (n) = 2T ( n / 2 ) + n

T ( 2 ) = 2T ( 2 / 2 ) + 2
T ( 2 ) = 2(1) + 2 = 4

Para c =2 la hiptesis inductiva corresponde con la recurrencia.

T ( 2 ) 2c
T ( 2 ) 2(2) = 4
Cuando n0=2 la hiptesis inductiva se cumple.
Dado que se encontr la forma exacta de la hiptesis con n grande y no se lleg a
inconsistencias con n pequea, queda demostrado que T ( n) = O (n log n) .

3.7.3 Consejos para una buena adivinacin


a) Usar la solucin de una recurrencia similar a la recurrencia con solucin conocida.
Recurrencia con solucin conocida

T (n)c = 2T ( n / 2 ) + n
T(n)c = O(nlgn)
Recurrencia con solucin desconocida

T (n)c = 2T ( n / 2 ) + 32 + n
Probar la solucin
T(n) c = O(nlgn)
b) Probar lmites superiores e inferiores holgados y despus reducirlos hasta que converjan.
Para la recurrencia

T (n) = 2T ( n / 2 ) + n
Probar como lmite inferior el costo no recursivo

T (n) = ( n )
Probar como lmite superior una potencia del costo no recursivo

Instituto Tecnolgico de Ciudad Madero


Unidad I COMPLEJIDAD DE ALGORITMOS

Dra. Laura Cruz Reyes


Captulo 3 Complejidad de algoritmos recursivos

T (n) = ( n )
Reducir el lmite superior y elevar el lmite inferior hasta que converjan en el correcto
T(n) = (nlgn)
c) Convertir una suposicin inductiva dbil en una fuerte, restando el trmino de ms bajo
orden.
Suposicin inductiva dbil
Recurrencia a resolver:

T (n) = 2T ( n / 2 ) + 2T ( n / 2 ) + 1
Adivinacin de la frmula de la solucin:

T ( n) = O ( n)
Hiptesis inductiva: existe una c>0 que haga cierto que,

T ( n) c( n)
Sustitucin en la recurrencia de la hiptesis inductiva evaluada en kf-1 = n/2

T (n) cn / 2 + cn / 2 + 1
T (n) cn + 1
La hiptesis inductiva se rechaza ya que no existe una c que haga cierta la hiptesis en la
recurrencia ya que para toda c>1, cn cn+1
Suposicin inductiva fuerte
El trmino de ms bajo orden de la recurrencia es 1, el cual se resta de la hiptesis
inductiva como una constante, quedando:

T (n) c(n) b, con b 0


Sustituyendo en la recurrencia la hiptesis inductiva evaluada en kf-1 = n/2 se tiene:

T (n) cn / 2 b + cn / 2 b + 1
T (n) cn 2b + 1
Para b=1 la recurrencia y la hiptesis coinciden
Recurrencia

Instituto Tecnolgico de Ciudad Madero


Unidad I COMPLEJIDAD DE ALGORITMOS

Dra. Laura Cruz Reyes


Captulo 3 Complejidad de algoritmos recursivos

T (n) cn 2(1) + 1
T (n) cn 1
Hiptesis

T (n) cn b
T (n) cn 1
d) Cambio de variables.
Mediante una manipulacin algebraica hacer que una recurrencia desconocida sea similar a
una conocida
Por ejemplo:

T (n) = 2T ( n ) + lg n .
Para eliminar el logaritmo se introduciendo una nueva variable m=lgn.

n = 2m
T (2m ) = 2T ( 2m ) + m
T (2m ) = 2T (2m / 2 ) + m
La recurrencia original T se renombra con S, cuyo tamao de problema es m.

S (m) = T (2m )

S (m) = 2S (m / 2) + m
La nueva recurrencia S es similar a otra recurrencia de solucin conocida.

T (n) = 2T (n / 2) + n

T (n) = O(n log n)


Por lo tanto, S tiene la misma solucin que la recurrencia conocida.

S (m) = O(m log m)


Se restablecen los valores originales para obtener la solucin de la recurrencia original.

T (n) = T (2m ) = S (m)


T (n) = O(m lg m) = O (lg n(lg(lg n))) ,
T (n) = O(log n lg 2 n)

Instituto Tecnolgico de Ciudad Madero

Dra. Laura Cruz Reyes


Captulo 3 Complejidad de algoritmos recursivos

Unidad I COMPLEJIDAD DE ALGORITMOS

3.8 Ejercicios resueltos


En los siguientes ejercicios, para la funcin de recurrencia dada, se aplican los mtodos de
solucin indicados. Posteriormente se determine el orden asinttico de la funcin. Finalmente la
solucin la solucin se comprueba utilizando la herramienta Derive.
3.8.1. Utilice el mtodo maestro y al rbol de recurrencia para resolver la funcin T(n)
definida para todas las potencias de 2.

T (n) = n -1 + 2T ( n / 2 )
T (1) = 0
a) Aplicacin de mtodos de solucin de recurrencias
Mediante un anlisis del rbol de recurrencia se observa que la complejidad en los
diferentes niveles del rbol no es constante y tampoco es una serie geomtrica. Por lo
anterior el teorema maestro no se puede utilizar para resolver la recurrencia.

Complejidad
T(n)

T(n/2)

T(n/4)

n-1

n-1

(n/2)-1

(n/4)-1

T(n/4)

T(n/2)

(n/4)-1

T(n/4)

(n/4)-1

(n/2)-1

T(n/4)

n-2

(n/4)-1

n-4
.
.

n-2i
Para facilitar la identificacin de patrones, se elabora una tabla que resume la evolucin
del tamao del problema, la complejidad de un nodo y la complejidad de un nivel.

Nivel Tamao
i
del
problema
0
n
1
n/2
2
n/4
#
#
9i
n
2i
#
#
m
n
=1
2m

Complejidad
(de un
subproblema)
n-1
n/2 -1
n/4 -1
#
n
1
2i
#
n

T m = T (1) = 0
2

Patrn de Complejidad: n-2i

No. de
Complejidad
suproblemas (de todo el nivel)
1
2
4
#
2i

#
2m

1(n-1) = n-1
2(n/2 -1) = n-2
4(n/4 -1) = n-4
#
n 2i

#
n
2m T m
2

m
m
= 2 T (1) = 2 (0)

Instituto Tecnolgico de Ciudad Madero

Dra. Laura Cruz Reyes


Captulo 3 Complejidad de algoritmos recursivos

Unidad I COMPLEJIDAD DE ALGORITMOS


m 1

m 1

m 1

i =0

i =0

i =0

T ( n) = ( n 2i ) + 2 m T (1) = (n 2i ) + 2m (0) = ( n 2i )

Para i = m, que es el tamao de problema ms pequeo, y aplicando: b L = x ; log b x = L


n
T m = T (1)
2
n
=1
2m
2m = n
m = lg n

Logrando con ello establecer el lmite al cual llegar i, es decir, la profundidad del rbol
Utilizando la serie geomtrica

= 2 k +1 1

i =0

T ( n) =

lg n -1

lg n -1

lg n -1

i =0

i =0

( n - 2i ) = n - 2 i
i =0

lg n -1

lg n -1

i =0

i =0

T ( n) = n 1- 2i = n(lg n) - (2(lg n-1) +1 -1) = n(lg n) - 2lg n + 1


T ( n) = n lg n - n + 1

b) Determinacin del orden asinttico


T ( n) = ( n lg n)
c) Comprobacin con Derive
GEOMETRIC1 es una funcin que resuelve ecuaciones de recurrencia linear-geomtrica obtenidas
de algoritmos de los tipos divide-y-vencers. La Funcin T(n) se debe transformar para adquirir la
forma esperada por GEOMETRIC1.

T (n) = n 1 + 2T ( n / 2 ) , T (1) = 0
T (2n) = 2T ( n ) + 2n 1
y (kx) = p ( x) y ( x) + q ( x)
k = 2, x = n,

p ( x) = 2, q ( x) = 2n 1, x0 = 1,

GEOMETRIC1(k , p ( x), q ( x), x, x0 , y0 )

y0 = 0

Instituto Tecnolgico de Ciudad Madero

Dra. Laura Cruz Reyes


Captulo 3 Complejidad de algoritmos recursivos

Unidad I COMPLEJIDAD DE ALGORITMOS

#1: GEOMETRIC1(2, 2, 2n - 1, n, 1, 0)
nLN(n)
- n + 1
LN(2)

#2:

3.8.2. Utilice el mtodo maestro para resolver la funcin W definida por la ecuacin de recurrencia
y caso base siguientes:
W (n) = 2W ( n / 2 ) + n
W (1) = 0

a) Aplicacin de mtodos de solucin de recurrencias

W(n)

W(n/2)

W(n/4)

(1/4)n

Complejidad
n

(1/2)n

W(n/2)

(1/4)n

W(n/4)

W(n/4)

(1/2)n

(1/4)n

W(n/4)

(1/4) n

Observando el rbol de recurrencia se puede notar que el patrn de complejidad se mantiene


constante, correspondiendo al caso 2 del mtodo maestro.
De la formula general de divide-y-vencers se tiene:
T ( n ) = bT ( n / c ) + f ( n )
b = 2, c = 2, f ( n ) = n

Demostrar que f ( n ) = ( n log b ) , requiere identificar las funciones f(n) y g(n)


f ( n) = n
c

g (n) = n lg 2 2 = n

Como f ( n ) = g ( n ) , se demuestra que f ( n ) = ( n log b )


c

Del teorema maestro se obtiene la forma asinttica de la solucin


W (n) = (n logc b lg n) = (n log2 2 lg n) = (n lg n)

Instituto Tecnolgico de Ciudad Madero

Dra. Laura Cruz Reyes


Captulo 3 Complejidad de algoritmos recursivos

Unidad I COMPLEJIDAD DE ALGORITMOS

b) Comprobacin con Derive


W ( n) = 2W ( n / 2 ) + n, W (1) = 0
W (2n) = 2W ( n ) + 2n
y ( kx ) = p ( x ) y ( x) + q ( x )
k = 2, x = n, p ( x ) = 2, q ( x ) = 2n
GEOMETRIC1( k , p ( x ), q ( x ), x, x 0, y 0)
#1:

GEOMETRIC1(2, 2, 2n, n, 1, 0)
nLN(n)

LN(2)

#2:

3.8.3. Utilice el mtodo maestro y el rbol de recurrencia para resolver la funcin T definida por la
ecuacin de recurrencia y caso base siguientes:
T ( n) = T ( n / 2) + lg n,

T (1) = 1

a) Aplicacin de mtodos de solucin de recurrencias


Del anlisis del rbol de recurrencia se observa que la complejidad no es constante y no es una serie
geomtrica decreciente, por lo que no posible aplicar el Teorema maestro para resolver la
recurrencia.

T(n)

lgn

Complejidad
lgn

T(n/2)

lg(n/2)

lg(n/2)

T(n/4)

lg(n/4)

lg(n/4)
.
.
.

lg(n/2i)

Nivel
i
0
1
2
#
i
#
m

Tamao del
problema
n
n/2
n/4
#
n/2i
#
n/2m=1

Complejidad
(de un subproblema)
lg n
lg(n/2)
lg(n/4)
#
lg(n/2i)
#
T(n/2m)=T(1)=1

No. de
subproblemas
1
1
1
1
1
1
1

Complejidad
(de todo el nivel)
lg n
(lg(n/2))
(lg(n/4))
#
lg(n/2i)
#
T(n/2m)= T(1)=1

Instituto Tecnolgico de Ciudad Madero

Dra. Laura Cruz Reyes


Captulo 3 Complejidad de algoritmos recursivos

Unidad I COMPLEJIDAD DE ALGORITMOS

n
Patrn de complejidad: lg i
2

Para i=m, que es el tamao de problema ms pequeo, y aplicando: b L = x ; log b x = L

T (n / 2m ) = T (1)
n
=1
2m
2m = n
m = lg n
Logrando con ello establecer el lmite al cual llegar i, es decir la profundidad del rbol
T ( n) =

lg n 1

lg ( n 2 ) + T (1)
i

i =0

T ( n) =

lg n 1

lg n 1

lg n lg 2
i =0

i =0

lg n 1

lg n 1

i =0

i =0

+ 1 = lg n 1

i +1

lg n(lg n 1)
(lg n) 2 lg n
2
T (n) = lg n(lg n)
+ 1 = (lg n)
+1
2
2
2(lg n) 2 (lg n) 2 + lg n
(lg n) 2 + lg n
T ( n) =
+1 =
+1
2
2

b) Determinacin del orden asinttico


T (n) = ((lg n) 2 )
c) Comprobacin con Derive
T (n) = T (n / 2) + lg n, T (1) = 1
T (2n) = T ( n ) + lg 2n
y (kx) = p( x) y ( x) + q( x)
k = 2, x = n, p( x) = 1, q( x) = lg 2n
GEOMETRIC1(k , p( x), q( x), x, x0, y 0)
#1:

#2:

GEOMETRIC1(2, 1, LOG(2n, 2), n, 1, 1)


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

Instituto Tecnolgico de Ciudad Madero

Dra. Laura Cruz Reyes


Captulo 3 Complejidad de algoritmos recursivos

Unidad I COMPLEJIDAD DE ALGORITMOS

3.8.4. Utilice el mtodo maestro para resolver la funcin T definida por la ecuacin de recurrencia
y caso base siguientes: T (n) = T (n / 2) + n, T (1) = 1
a) Aplicacin de mtodos de solucin de recurrencias
Del anlisis del rbol de recurrencia se observa que la complejidad es una serie geomtrica
decreciente, por lo que es recomendable aplicar el caso 3 del Teorema maestro.
T(n)

Complejidad
n

T(n/2)

(1/2)n

(1/2)n

T(n/4)

(1/4)n

(1/4)n

#
(1/2i)n

Nivel
i
0
1
2
#

Tamao del
problema
n
n/2
n/4
#

Complejidad
(de un subproblema)
n
n/2
n/4
#

Complejidad
(de todo el nivel)
n
n/2
n/4
#

De la formula general T ( n ) = bT ( n / c ) + f ( n ) se tiene se tiene b = 1, c = 2, f ( n ) = n .


Demostrar que f ( n) = ( n
f ( n) = n

log c b +

) para > 0 , requiere identificar las funciones f ( n ) y g ( n)

g (n) = n logc b + = n log 2 1+ = (n 0+ ) = (n )

Como f ( n / c ) c ' g ( n) se demuestra que f ( n) = ( n ) para = 1 y c= 1

El Teorema Maestro tambin pide demostrar que bf ( n / c ) c ' f ( n ) para c ' < 1 .

bf ( n / c ) n / 2
bf ( n) = 2 n para c ' = 2
3
3
Como existe una c ' < 1 , se demuestra que bf ( n / c ) c ' f ( n )
Cuando las demostraciones son exitosas, el teorema maestro seala que T (n) = ( f ( n ) ) .
Por tanto, la forma asinttica de la solucin queda:
T ( n ) = ( n )

Instituto Tecnolgico de Ciudad Madero

Dra. Laura Cruz Reyes


Captulo 3 Complejidad de algoritmos recursivos

Unidad I COMPLEJIDAD DE ALGORITMOS

b) Comprobacin con Derive


T (n) = T (n / 2) + n, T (1) = 1
T (2n) = T ( n ) + 2n
y (kx) = p ( x) y ( x) + q ( x)
k = 2, x = n, p ( x) = 1, q ( x) = 2n
GEOMETRIC1(k , p ( x), q ( x), x, x0, y 0)
#1:

GEOMETRIC1(2, 1, 2n, n, 1, 1)

#2:

2n - 1

3.8.5. Utilice el mtodo maestro para resolver la funcin T definida por la ecuacin de recurrencia
y caso base siguientes: T ( n) = 2T (n / 2) + n, T (1) = 1
a) Aplicacin de mtodos de solucin de recurrencias

T(n)
T(n/2)
T(n/4)

(1/4)n

T (n/2)

(1/2) n

T(n/4)

Complejidad
n

(1/4) n

T(n/4)

(1/2) n

(1/4) n

T(n/4)

(1/4) n

n
.
.

Nivel
i
0
1
2
#

Tamao del
problema
n
n/2
n/4
#

Complejidad
(de un subproblema)
n
n/2
n/4
#

Complejidad
(de todo el nivel)
n
=n
2(n/2) = n
4(n/4) = n
#

Observando el rbol de recurrencia se puede notar que el patrn de complejidad se mantiene


constante, correspondiendo al caso 2 del mtodo maestro.
De la formula general de divide-y-vencers T ( n ) = bT ( n / c ) + f ( n ) se tiene
b = 2, c = 2, f ( n ) = n

Demostrar que f ( n ) = ( n log b ) , requiere identificar las funciones f(n) y g(n)


f (n) = n, g (n) = n lg 2 2 = n
c

Instituto Tecnolgico de Ciudad Madero

Dra. Laura Cruz Reyes


Captulo 3 Complejidad de algoritmos recursivos

Unidad I COMPLEJIDAD DE ALGORITMOS

Como f (n) = g (n) ,se demuestra que f ( n ) = ( n log b )


c

Del teorema maestro se obtiene la forma asinttica de la solucin


W (n) = (n logc b lg n) = (n log2 2 lg n) = (n lg n)
b) Comprobacin con Derive
T ( n) = 2T (n / 2) + n, T (1) = 1
T (2n) = 2T ( n ) + 2n
y (kx ) = p ( x ) y ( x ) + q ( x)
k = 2, x = n, p ( x ) = 2, q ( x ) = 2n
GEOMETRIC1(k , p, q, x, x0, y 0)
#1:

GEOMETRIC1(2, 2, 2n, n, 1, 1)
nLN(n)
+ n
LN(2)

#2:

3.8.6. Utilice el mtodo maestro y el rbol de recurrencia para resolver la funcin T definida por la
ecuacin de recurrencia y caso base siguientes:
T ( n) = 2T ( n / 2) + n lg n, T (1) = 1

a) Aplicacin de mtodos de solucin de recurrencias


Del anlisis del rbol de recurrencia se observa que la complejidad no se mantiene constante y no es
una serie geomtrica decreciente, por lo que no es posible utilizar el Teorema maestro para la
solucin de la recurrencia

T(n)

T(n/2)

(1/2) n lg n/2

T(n/4) (n/4) n lg (n/4)


T(n/4)

T(n/2)

T(n/4)
(n/4) lg (n /4)

Complejidad
n lg n

n lg n

(n/2) lg (n/2)

n lg (n/4)

(n/4) lg (n/4)

T(n /4)

n lg (n/2)

(n /4) lg (n/4)

.
.
.
.

n lg (n/2i)

Instituto Tecnolgico de Ciudad Madero

Dra. Laura Cruz Reyes


Captulo 3 Complejidad de algoritmos recursivos

Unidad I COMPLEJIDAD DE ALGORITMOS

Nivel
i

Tamao del
problema

0
1
2

n
n/2
n/4

#
i
#
m

#
n/2i

#
n/2

Complejidad
(de un
subproblema)
n lg n
(n/2)lg(n/2)
(n/4)lg(n/4)
#
(n/2i)lg(n/2i)
#
m
T(n/2 )=T(1)=1

No. de
subproblemas

Complejidad
(de todo el nivel)

2
4
8

1(n lg n)
= n lg(n)
2((n/2) lg(n/2)) = n lg(n/2)
4((n/4) lg(n/4)) = n lg(n/4)
#
n lg(n/2i)
#
m
m
2 T(n/2 )= 2m T(1)

2i
2m

n
Patrn de complejidad: n lg i
2

Para i = m , que es el tamao de problema ms pequeo, y aplicando: b L = x ; log b x = L

T (n / 2m ) = T (1)
n
=1
2m
2m = n
m = lg n
Logrando con ello establecer el lmite al cual llegar i, es decir, la profundidad del rbol
m 1
n
T ( n) = n lg i
2
i =0

m
+ 2 T (1) =

lg n 1

n log n
+ 2 T (1)
i

n lg 2
i =0

lg n 1

lg n 1

lg n 1

lg n 1

lg n 1

lg n 1

i =0

i =0

i =0

i =0

i=0

i =1

T ( n) = n lg n n lg 2i + n = n lg n 1 n i + n = n lg n 1 n i + n
lg n(lg n 1)
+n
2
1
1
T ( n) = n lg 2 n n lg 2 n + n lg n + n
2
2
1
1
T ( n) = n lg 2 n + n lg n + n
2
2
T ( n) = n lg n(lg n) n

b) Determinacin del orden asinttico

T ( n ) = ( n log 2 n )

Instituto Tecnolgico de Ciudad Madero

Dra. Laura Cruz Reyes


Captulo 3 Complejidad de algoritmos recursivos

Unidad I COMPLEJIDAD DE ALGORITMOS

c) Comprobacin con Derive


T (n) = 2T (n / 2) + n lg n, T (1) = 1
T (2n) = 2T ( n ) + 2n(lg 2n)
y (kx) = p( x) y ( x) + q( x)
k = 2, x = n, p( x) = 2, q( x) = 2n lg 2n
GEOMETRIC1(k , p( x), q( x), x, x0, y 0)

#1:

GEOMETRIC1(2, 2, 2nLOG(2n, 2), n, 1, 1)


2
nLN(n)
nLN(n)
+ + n
2
2LN(2)
2LN(2)

#2:

3.8.7. Utilice el mtodo maestro y el rbol de recurrencia para resolver la funcin T definida por la
ecuacin de recurrencia y caso base siguientes:
T (n) = 2T (n / 2) + n 2 , T (1) = 1

a) Aplicacin de mtodos de solucin de recurrencias


Del anlisis del rbol de recurrencia se observa que la complejidad es una serie geomtrica
decreciente, por lo que para la solucin de la recurrencia se utilizar el caso 3 del Teorema
Maestro.

T(n)
T (n/2)

T(n/4)

(1/16)n2

(1/4) n2

T(n/4)

Complejidad
n2

n2

T(n/2)

(1/16)n2

T(n/4)

(1/16)n2

(1/4) n2

T(n/4)

(1/2) n2

(1/16)n2

(1/4) n2
.
.

(1/2i) n2

1/4

Instituto Tecnolgico de Ciudad Madero

Dra. Laura Cruz Reyes


Captulo 3 Complejidad de algoritmos recursivos

Unidad I COMPLEJIDAD DE ALGORITMOS

Nivel
i

Tamao del
problema

0
1
2
3

n
n/2
n/4
n/8

Complejidad
(de un
subproblema)
n2
(n/2)2
(n/4)2
(n/8)2
#

Complejidad
(de todo el nivel)
1 n2
2 (n/2)2
4 (n/4)2
8 (n/8)2

= (1/1) n2
= (1/2) n2
= (1/4) n2
= (1/8) n2
#

De la formula general T (n) = bT (n / c) + f (n) se tiene b = 2, c = 2,

f (n) = n 2

Demostrar que f ( n) = ( n logc b + ) para > 0 , requiere identificar las funciones f ( n ) y g ( n )

f ( n) = n 2
g ( n) = ( n log c b + ) = ( n1+ )
1+
Como f ( n ) c g ( n ) , se demuestra que f ( n) = ( n ) para = 1 y c= 1

El Teorema Maestro tambin pide demostrar que bf ( n ) c f ( n ) para c ' < 1 .

( c ) ( 2)
c ' f (n) = ( 2 ) n
3

bf n

=2 n

=n

para c ' = 2

Como existe una c ' < 1 , se demuestra que bf ( n ) c f ( n )


Cuando las demostraciones son exitosas, el teorema maestro seala que T ( n ) = ( f ( n ) ) . Por
tanto, la forma asinttica de la solucin queda:
T ( n ) = ( n2 )

b) Comprobacin con Derive


T (n) = 2T (n / 2) + n 2 , T (1) = 1
T (2n) = 2T ( n ) + 4n 2
y (kx) = p( x) y ( x) + q( x)
k = 2, x = n, p( x) = 2, q( x) = 4n 2
GEOMETRIC1(k , p( x), q( x), x, x0, y 0)

Instituto Tecnolgico de Ciudad Madero

Dra. Laura Cruz Reyes


Captulo 3 Complejidad de algoritmos recursivos

Unidad I COMPLEJIDAD DE ALGORITMOS

#1:
#2:

GEOMETRIC1(2, 2, 4n ^2 , n, 1, 1)
2
2n - n

3.8.8. Utilice el mtodo de rbol de recurrencia para resolver la funcin:


T( 1 ) = 1, T( n ) = 3T( n - 1 ) + 2
a) Aplicacin de mtodos de solucin de recurrencias

T(n-1)

T(n-2)

T(n-2)

T(n-1)

Complejidad
2

T(n-1)

T(n-2)

Tamao del
problema
n-1
n-2
n-3
#
n-i
#
n-m

T(n-2)
T(n-2)

T(n-2)

T(n-2)

Complejidad
(de un subproblema)
2
2
2
#
2
#
T(n-m)=T(1)=1

T(n-2)

No. de
subproblemas
3
9
27
3i
3m

2(3)

T(n-2)

Nivel
i
0
1
2
#
i
#
m

T(n)

2(9)
.
.
.

2(3i)

Complejidad
(de todo el nivel)
3(2)
9(2)
27(2)
#
3i (2)
#
m
m
3 T(n-m)=3 T(1) =3m(1)

Patrn de Complejidad: 2(3i )


m 1

T ( n) = 2 3i + 3m (1)
i =0

Para i=m, que es el tamao de problema ms pequeo, y aplicando: b L = x ; log b x = L


T(n-m)=T(1)
n-m=1
m=n1

Instituto Tecnolgico de Ciudad Madero

Dra. Laura Cruz Reyes


Captulo 3 Complejidad de algoritmos recursivos

Unidad I COMPLEJIDAD DE ALGORITMOS

Logrando con ello establecer el lmite al cual llegar i, es decir, la profundidad del rbol
n2
3n 2+1 1 n 1
3n 1 1 n 1
T (n) = 2 3i + 3n 1T (1) = 2
+
=
3
2

+3

3
1
2
i =0

T (n) = 3n 1 1 + 3n 1 = 2 ( 3n 1 ) 1 = (3n )

b) Comprobacin con Derive


LIN1_DIFFERENCE es una funcin que resuelve ecuaciones de recurrencia de primer orden
obtenidas de algoritmos de los tipos recorta-y-vencers. La Funcin T(n) se debe transformar para
adquirir la forma esperada por LIN1_DIFFERENCE.
T (n) = 3T (n -1 ) + 2, T (1) = 1
T (n + 1) = 3T ( n ) + 2
y ( x + 1) = p ( x) y ( x) + q ( x)
x = n, p ( x) = 3, q ( x) = 2
LIN1_DIFFERENCE( p ( x), q ( x), x, x0, y 0)
#1:

LIN1_DIFFERENCE(3, 2, n, 1, 1)

#2:

23

n - 1

- 1

3.8.9. Utilice el mtodo de expansin para resolver la siguiente recurrencia:


T(1)=8, T(n)=3T(n-1)-15
a) Aplicacin de mtodos de solucin de recurrencias
La ecuacin inductiva se expresa con diferentes tamaos de problema
T ( n)
= 3T ( n 1) 15
T ( n 1) = 3T ( n 2) 15
T ( n 2) = 3T ( n 3) 15
La ecuacin inductiva se expande
Expansin con T ( n)
T ( n) = 3T ( n 1) 15
Expansin con T (n 1)

T (n) = 3 ( 3T (n 2) 15 ) 15 = (3)(3)T (n 2) 3(15) 15 = 15 3(15) + 32 T (n 2)

Instituto Tecnolgico de Ciudad Madero

Dra. Laura Cruz Reyes


Captulo 3 Complejidad de algoritmos recursivos

Unidad I COMPLEJIDAD DE ALGORITMOS

Expansin con T ( n 2)

T (n) = (3)(3) ( ( 3T (n 2) 15) ) (3)15 15 = 15 3(15) 32 (15) + 33 T (n 3)

La ecuacin inductiva se expresa con sumatorias


m 1

T (n) = 15 3i + 3m T (n m)
i =0

En el caso base, T (1) = 8 , por lo tanto n m = 1 y m = n 1


T ( n) = 15

( n 1) 1

3i + 3n 1T (1)

i =0
n2

T (n) = 15 3i + 3n 1T (1)
i =0

3n 1 1
n 1
T (n) = (15)
+ (3 )(8)
2

n 1
T (n) = 3 ( 8 15 2 ) + 15 2

T ( n) =

3n 1 + 15
2

b) Comprobacin con Derive


T (n) = 3T (n -1) -15, T (1) = 8
T (n + 1) = 3T ( n ) 15
y ( x + 1) = p ( x) y ( x) + q ( x)
x = n, p ( x) = 3, q ( x) = 15
LIN1_DIFFERENCE( p ( x), q ( x), x, x0, y 0)
#1:

#2:

LIN1_DIFFERENCE(3, -15, n, 1, 8)
n - 1
3
15
+
2
2

3.8.10. Utilice el mtodo de expansin para resolver la siguiente recurrencia:


T (1) = 2 , T ( n) = T ( n 1) + n 1

Instituto Tecnolgico de Ciudad Madero

Dra. Laura Cruz Reyes


Captulo 3 Complejidad de algoritmos recursivos

Unidad I COMPLEJIDAD DE ALGORITMOS

a) Aplicacin de mtodos de solucin de recurrencias


La ecuacin inductiva se expresa con diferentes tamaos de problema
T ( n)

= T ( n 1) + n 1

T ( n 1) = T ( n 2) + n 2
T ( n 2) = T ( n 3) + n 3

La ecuacin inductiva se expande


Expansin con T ( n)
T (n) = n 1 + T (n 1)
Expansin con T (n 1)
T ( n) = n 1 + (T ( n 2) + n 2) = ( n 1) + ( n 2) + T ( n 2)
Expansin con T ( n 2)
T ( n) = ( n 1) + ( n 2) + (T ( n 3) + n 3) = ( n 1) + (n 2) + ( n 3) + T ( n 3)
La ecuacin inductiva se expresa con sumatorias
m

T ( n ) = ( n i ) + T ( n m)
i =1

En el caso base, T (1) = 2 , por lo tanto n m = 1 y m = n 1


n 1

n 1

T ( n) = ( n i ) + T (1) = ( n i ) + 2
i =1

i =1

n 1

n 1

i =1

i =1

T ( n) = ( n) (i ) + 2 = n(n 1)
T ( n) = n 2 n

( n 1)( n)
+2
2

n2 n
n2 n
+ +2=
+2
2 2
2 2

b) Comprobacin con Derive


T (n) = T (n 1) + n 1, T (1) = 2
T (n + 1) = T ( n ) + n
y ( x + 1) = p ( x) y ( x) + q ( x)
x = n, p ( x) = 1, q ( x) = n
LIN1_DIFFERENCE( p ( x), q ( x), x, x0, y 0)

Instituto Tecnolgico de Ciudad Madero

Dra. Laura Cruz Reyes


Captulo 3 Complejidad de algoritmos recursivos

Unidad I COMPLEJIDAD DE ALGORITMOS

#1:

LIN1_DIFFERENCE(1, n, n, 1, 2)
2
n
n
- + 2
2
2

#2:

3.9 Ejercicios propuestos


3.9.1

Usando la notacin vista en el curso de Anlisis y Diseo de Algoritmos II, escriba la


definicin de cada tipo de funcin de recurrencia de la lista de abajo. Para cada tipo de
funcin, tambin presente un ejemplo y su solucin con alguno de los mtodos vistos en el
curso de anlisis y diseo de Algoritmos I.
a)
b)
c)
d)
e)

Recurrencia homognea lineal de primer-orden con coeficientes constantes


Recurrencia homognea lineal de segundo-orden con coeficientes constantes
Recurrencia no-homognea de primer-orden
Recurrencia no-homognea de segundo-orden
Recurrencia no-lineal

3.9.2

Use el rbol de recurrencia para resolver las recurrencias de los ejercicios 3.8.2 y 3.8.4,
3.8.5, 3.8.7

3.9.3

Resuelva las siguientes recurrencias usando el mtodo maestro, rbol de recurrencia y


expansin. Verifique la solucin con la herramienta Derive.
3T (n / 2) + n 2 + n..........n 2
T ( n) =
1..................................n = 1

3.9.4

Resuelva las siguientes recurrencias usando el mtodo maestro, rbol de recurrencia y


expansin. Verifique la solucin con la herramienta Derive.
T (n 2) + 3n + 4..........n 3

T (n) = 1..................................n = 1

6..................................n = 2

3.9.5

Encuentre un ejemplo de recurrencia de solucin conocida en el que las siguientes reglas


maestras obtienen la misma solucin que las reglas utilizadas en los ejercicios resueltos.
Para recurrencias con la forma general T (n) = bT (n c) + an k , la solucin de la recurrencia
se obtiene con las siguientes reglas:

Instituto Tecnolgico de Ciudad Madero

Dra. Laura Cruz Reyes


Captulo 3 Complejidad de algoritmos recursivos

Unidad I COMPLEJIDAD DE ALGORITMOS

( n k )

T (n) = (n k log n)

log c b
( n )

si b < c k
si b = c k
si b > c k

Bibliografa

1. CormenT.H., LeisersonC.E., RivestR.L: Introduction to Algorithms, MIT Press 1990.


2. Sara Basse, Allen Van Gelder. Algoritmos Computacionales: Introduccin al anlisis y
diseo. Tercera Edicin. AddisonWesley. 2002.

3. Ian Parberry, William Gasarch. Problems on Algorithms. Prentice Hall, 1994