Académique Documents
Professionnel Documents
Culture Documents
Departamento de Ingeniera
Abancay - 2013.
Contenido
Introduccin ....................................................................................................................................... 3
Asntotas........................................................................................................................................... 16
Ecuaciones de Recurrencia............................................................................................................... 23
Bibliografa ...................................................................................................................................... 33
Pg. 2
Complejidad de los algoritmos recursivos
Introduccin
Por lo tanto el presente Manual nos ha de permitir medir de alguna forma el costo
(en funcin del tiempo) que consume un algoritmo para encontrar la solucin y nos
problema.
Eficiencia y complejidad
Simplicidad
Uso eficiente de los recursos:
o el espacio (memoria que utiliza)
o y el tiempo (lo que tarda en ejecutarse).
Eficiencia temporal
Principio de Invarianza
Dado un algoritmo y dos implementaciones suyas I1 e I2, que tardan T1(n) y T2(n)
segundos respectivamente, el Principio de Invarianza afirma que existe una constante real
c > 0 y un nmero natural n0 tales que para todo n n0 se verifica que T1(n) cT2(n).
Con esto podemos definir sin problemas que un algoritmo tarda un tiempo del orden
de T(n) si existen una constante real c > 0 y una implementacin I del algoritmo que tarda
menos que cT(n), para todo n tamao de la entrada.
Dos factores a tener muy en cuenta son la constante multiplicativa y el n0 para los que
se verifican las condiciones, pues si bien a priori un algoritmo de orden cuadrtico es
mejor que uno de orden cbico, en el caso de tener dos algoritmos cuyos tiempos de
ejecucin son 106n2 y 5n3 el primero slo ser mejor que el segundo para tamaos de la
entrada superiores a 200.000.
De los tres casos el que consideramos de mayor importancia es el caso peor, por las
siguientes razones:
Es el ms informativo (el caso mejor suele ser trivial).
Nos permitir acotar superiormente el consumo de recursos: sabremos que nuestro
programa
no consumir ms de lo estimado.
Es ms fcil de calcular que el caso medio.
Ejemplo
Sea A una lista de n elementos A1, A2, A3, ... , An. Ordenar significa permutar estos
elementos de tal forma que los mismos queden de acuerdo con un orden preestablecido.
Ascendente A1 <=A2 <=A3 ..........<=An
Descendente A1 >=A2 >=........>=An
Caso peor: Que el vector est ordenado en sentido inverso.
Caso mejor: Que el vector est ordenado.
Caso medio: Cuando el vector est desordenado aleatoriamente
Son las operaciones bsicas, asignaciones a variables, los saltos, llamadas a funciones y
procedimientos, retorno de ellos, etc.
Las comparaciones lgicas y el acceso a estructuras indexadas, como los vectores y
matrices. Cada una de ellos cuenta como 1 OE.
Por lo tanto al medir el tiempo, siempre lo haremos en funcin del nmero de OEs,
para un tamao de entrada dado.
La siguiente lista presenta un conjunto de reglas generales para el clculo del nmero de
OE, siempre considerando el peor caso.
3ro Caso medio: En el caso medio, el bucle se ejecutar un nmero de veces entre 0 y
n1, y vamos a suponer que cada una de ellas tiene la misma probabilidad de suceder.
Como existen n posibilidades (puede que el nmero buscado no est) suponemos a priori
que son equiprobables y por tanto cada una tendr una probabilidad asociada de 1/n. Con
esto, el nmero medio de veces que se efectuar el bucle es de:
n 1
1 n 1
i n
i 0 2
Tenemos pues que n 1 2
T(n) 1 2 ( 4 2 ) 4 2 1 3n 7 OE
i 1
En la prctica no se trabaja con T(n) sino con funciones que clasifiquen estas
funciones acotando su valor asintticamente. Por ejemplo: si el T(n) de un algoritmo es:
10n 2
T(n) 2n
3
Diremos que T(n) pertenece O(n2) como lo veremos posteriormente en el tema de
asntotas.
Ejercicios:
1. Read(n)
2. s=0
3. i=1
4. While(i<=1) do
5. s=s+1
6. i=i+1
7. End(While)
8. Write(n,s)
a. Mejor Caso: En el mejor de los casos no entra en el bucle While por lo cual se
ejecutan las siguientes operaciones elementales.
t(n) = 5 OE
1. read(n) 1 OE
2. s=0 1 OE
3. i=1 1 OE
4. while(i<=1) do 1n +1 OE (n vueltas + 1 evaluacin de salida)
5. s=s+1 2n OE
6. i=i+1 2n OE
7. end(while)
8. write(n,s) 1 OE
t(n) = 5n+5 OE
c. Caso medio: En el caso medio como se explico en el ejercicio 1, los bucles se dividen
entre la mitad de vueltas que den los bucles, por lo cual se tiene:
1. Read(n) 1 OE
2. s=0 1 OE
3. i=1 1 OE
4. While(i<=1) do 1n/2+1 OE
5. s=s+1 2n/2 OE
6. i=i+1 2n/2 OE
7. End(While)
8. Write(n,s) 1 OE
t(n) = 5n/2+5 OE
1. Read(n)
2. s=0
3. i=1
4. While(i<=1) do
5. s=s+1
6. i=i+1
7. End(While)
8. Write(n,s)
a. Mejor Caso: En el mejor de los casos no entra en el bucle While por lo cual se
ejecutan las siguientes operaciones elementales.
t(n) = 5 OE
1. read(n) 1 OE
2. s=0 1 OE
3. i=1 1 OE
4. while(i<=1) do 1n +1 OE (n vueltas + 1 evaluacin de salida)
5. s=s+1 2n OE
6. i=i+1 2n OE
7. end(while)
8. write(n,s) 1 OE
t(n) = 5n+5 OE
c. Caso medio: En el caso medio como se explico en el ejercicio 1, los bucles se dividen
entre la mitad de vueltas que den los bucles, por lo cual se tiene:
1. Read(n) 1 OE
2. s=0 1 OE
3. i=1 1 OE
4. While(i<=1) do 1n/2+1 OE
5. s=s+1 2n/2 OE
6. i=i+1 2n/2 OE
7. end(while)
8. Write(n,s) 1 OE
t(n) = 5n/2+5 OE
En adelante consideraremos solo el caso peor por ser de mayor representatividad para
nuestros fines.
Si en un inicio n=32 y el bucle termina dando 5 entradas, entonces la relacin que existe
entre 32 y 5 es: Log 2 32=5, por consiguiente cada instruccin del ciclo se ejecuta un
nmero de veces igual al logaritmo en base dos de n. Por lo tanto:
1. Read(n) 1 OE
2. S=0 1 OE
3. While n>1 do (Log2n)+1 OE
4. S=S+1 2*(Log2n) OE
5. n=n/2 2*(Log2n) OE
6. End(While)
7. Write (n,S) 1 OE
t(n) = 5 Log2n+3
1. Read(n)
2. S=0
3. While n>1 do
4. S=S+1
5. n=n/3
6. End(While)
7. Write (n,S)
Aqu la variable controladora se divide por 3 dentro del ciclo. Damos un valor
arbitrario a n para ver su comportamiento n=81, haciendo el seguimiento tenemos. En la
primera pasada n=27, en la segunda n=9, el la tercera n=3 y en la cuarta sale con n=1 y
finaliza el bucle. Ahora la relacin que existe entre n=81 y 4 vueltas del bucle es:
Log381=4.
Ahora si analicemos nuestro algoritmo lnea por lnea, incluyendo las vueltas del
bucle, obtenemos:
1. Read(n) 1 OE
2. S=0 1 OE
3. While n>1 do (Log3n)+1
4. S=S+1 2*(Log3n)
5. n=n/3 2*(Log3n)
6. End(While)
7. Write (n,S) 1 OE
t(n) = 5 Log3n + 3
Nota: Para calcular el nmero de Operaciones Elementales del bucle FOR hacemos la
conversin a su equivalente bucle WHILE:
1. i=1 1OE
2. While i<=n do 1OE
1. for i:=1 to n do 3. Begin
2. begin 4. i:=i+1; 2OE
3. end; 5. End;
Como vemos una aproximada conversin en cuanto a su complejidad del bucle FOR al
WHILE es 4 OE por lo cual en adelante contabilizaremos a todo bucle FOR como 4 OE.
1. n:=Length(lista); 2 OE
2. for i:=0 to n-1 do (4+1)n +1OE multiplicado por n vueltas
3. begin
4. for j:=0 to n-1 do ((4+1)n+1) n OE se multiplican ambos bucles
5. begin
6. if lista[i]>lista[j] then 3n2 OE
7. begin
8. aux:=lista[i]; 2 n2 OE
9. lista[i]:=lista[j]; 3 n2 OE
10. lista[j]:=aux; 2 n2 OE
11. end;
12. end;
13. end;
t(n) = 15n2+6n+3
Asntotas
Para cada uno de estos conjuntos se suele identificar un miembro f(n) que se
utiliza como representante de la familia, hablndose del conjunto de funciones g que
son del orden de "f(n)", denotndose como:
O(f(n)) esta formado por aquellas funciones g(n) que crecen a un ritmo menor o igual que
el de f(n).
De las funciones g que forman este conjunto O(f(n)) se dice que estn
dominadas asintticamente por f, en el sentido de que para n suficientemente grande,
y salvo una constante multiplicativa k, f(n) es una cota superior de g(n).
Las siguientes propiedades se pueden utilizar como reglas para el clculo de rdenes de
complejidad. Toda la maquinaria matemtica para el clculo de lmites se puede aplicar
directamente:
g(n) IN O(f(n))
O(f(n)) = O(g(n))
g(n) IN O(f(n))
O(f(n)) es superconjunto de O(g(n))
Ejemplo:
Para demostrar que f(n) no es de orden cuadrtico basta tener en cuenta que:
0,013
lim = lim 0.01 =
2
2. Sea = 2 + 5 y = 3 + 2 2
2 +5 2 +5 2+1 2 2
Entonces lim = () = 3 +22 = == = 6 = = 0
3 +22 3 2 +2
( )
3. Sea = 2 + 5 y = 2
2 +5 2 +5 2+1 2
Entonces lim () = == = =2=1
2 2 2
( )
=
Para demostrar que f(n) es de orden cuadrtico basta tener en cuenta que:
+
lim
= lim
+ =
rdenes de complejidad
O(n log n)
El caso base, que maneja una entrada simple que puede ser resuelta sin una
llamada recursiva
La parte recursiva, que contiene una o ms llamadas recursivas al algoritmo,
donde los parmetros estn en un sentido ms cercano al caso base, que la
llamada original.
0! = 1
n! = n * (n-1)! si n>0
Ecuaciones de Recurrencia
Para resolver ese tipo de ecuaciones hay que encontrar una expresin no recursiva
de . (En algunos casos no es tarea fcil.)
El problema de las torres de Hanoi, tiene una solucin recursiva que se basa en
mover n 1 discos de A a B, luego el ms grande de A a C y finalmente los n 1 en B
haca C. Si definimos T (n) cantidad de movimientos de disco necesarios para resolver el
problema de las torres de Hanoi con n discos, obtenemos:
t(n) = 2 t(n 1) + 1
mover n 1 discos como si fuese el mismo problema de las torres de Hanoi (notar que
slo cambia a torre intermedia, la solucin es efectivamente la misma).
1. Primer mtodo: Suponer una solucin f(n), y usar la recurrencia para demostrar que
t(n) = f(n). La prueba se hace generalmente por induccin sobre n.
n t(n)+1
1 2
2 4
3 8
4 16
Cuadro 2: Algunos valores de t(n)+1
t(n) = 2 t(n1) + 1 es
t(n) = 2n 1.
t(n + 1) = 2n+1 2 + 1
t(n + 1) = 2n+1 1
Es importante tener en cuenta que cualquier solucin que encontremos con los
mtodos expuestos a continuacin pueden ser verificados utilizando esta misma
forma.
2. Segundo mtodo: Sustituir las recurrencias por su igualdad hasta llegar a cierta
( 0 ) que sea conocida.
Ejemplo:
1 , 1
() =
(1) + 2 , > 1
() = (1) + 2 (I)
(1) = (2) + 2
(2) = (3) + 2
(3) = (4) + 2
Luego de ello sustituimos sus equivalentes en (I), hasta obtener el k-esimo termino
de las sustituciones.
() = (1) + 2
() = (2) + 2 + 2
() = (2) + 22
() = (3) + 2 + 22
() = (3) + 32
() = () + 2 (II)
A) Primera forma
() = ( 1 , 2 , , , )
Un ejemplo muy conocido son los nmeros de Fibonacci, cuya ecuacin es:
() = 1 + 2
1+ 5 1 5
1 = , 2 =
2 2
1 1+ 5 1 5
=
5 2 2
B) Segunda Forma
0.
Teorema: La solucin para la ecuacin = 1 + es:
= +
=+1
= 1 + 1 =
En esta ecuacin es una variable muda y puede escribirse como:
1 =
(() (1) ) =
=+1 =+1
=
=+1
Obteniendo finalmente:
=
=+1
= 1 + 1, 0 = 0
C) Tercera forma
= +
=+1
1
= +
1 1
Notamos que = . Si definimos =
la ecuacion resultante es:
1
= 1 +
Usando el teorema propuesto obtenemos:
= 1 +
=+1
= +
=+1
= () +
=+1
= 2(1) + 1, 0 =0
La solucin es:
= 2 . 0 + 2
=1
=2 1
D) Cuarta Forma
una solucin exacta para = . Para simplificar el resultado, consideraremos
1 como condicin inicial conocida.
como solucin:
()
()
= (1) +
= , 1
=1
= + ( )
= 1 +
= 2 2
=1
= 2 2
2
= 2 ()
= 1 2 () 1 + 1 2
1
=1
2 ()
= 1 + 1
=1
= 1 + 2 ()
Bibliografa