Professional Documents
Culture Documents
Departamento de Ingeniera
Abancay - 2013.
Contenido
Introduccin ....................................................................................................................................... 3
Objetivo del manual ........................................................................................................................... 4
Eficiencia y complejidad .................................................................................................................... 4
Criterios para medir la eficiencia y complejidad de un algoritmo ................................................. 4
Eficiencia temporal ........................................................................................................................ 4
Operaciones Elementales (OE) ...................................................................................................... 6
Reglas generales para el clculo del nmero de OE ...................................................................... 7
Anlisis de mejor, peor y caso medio del algoritmo ...................................................................... 9
Asntotas........................................................................................................................................... 16
Propiedades de los Conjuntos O(f(n)) .......................................................................................... 17
rdenes de complejidad ................................................................................................................... 20
Complejidad de algoritmos recursivos ............................................................................................. 21
Clasificacin de funciones recursivas .......................................................................................... 22
Ecuaciones de Recurrencia............................................................................................................... 23
Bibliografa ...................................................................................................................................... 33
Pg. 2
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
permitir la posibilidad de comparar distintos algoritmos que resuelven un mismo
problema.
Pg. 3
Simplicidad
Eficiencia temporal
Depender de diversos factores como son:
La calidad del cdigo generado por el compilador para crear el programa objeto
Medida terica (a priori): Consiste en obtener una funcin que acote (por arriba
o por abajo) el tiempo de ejecucin del algoritmo para unos valores de entrada
dados.
(Se vera en las clases tericas)
2da
Pg. 4
un lenguaje concreto,
un compilador concreto y
datos concretos.
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).
Es decir, el tiempo de ejecucin de dos implementaciones distintas de un algoritmo dado
no va a diferir ms que en una constante multiplicativa.
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.
Pg. 5
De los tres casos el que consideramos de mayor importancia es el caso peor, por las
siguientes razones:
no consumir ms de lo estimado.
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
Operaciones Elementales (OE)
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.
Pg. 6
i:=1;
WHILE i<=n DO
S; INC(i)
END;
El tiempo de ejecucin de una llamada a un procedimiento o funcin F(P1, P2,...,
Pn) es 1 (por la llamada), ms el tiempo de evaluacin de los parmetros P1,
P2,..., Pn, ms el tiempo que tarde en ejecutarse F, esto es, T = 1 + T(P1) + T(P2)
+ ... + T(Pn) + T(F). No contabilizamos la copia de los argumentos a la pila de
ejecucin, salvo que se trate de estructuras complejas (registros o vectores) que se
pasan por valor. En este caso contabilizaremos tantas OE como valores simples
contenga la estructura. El paso de parmetros por referencia, por tratarse
simplemente de punteros, no contabiliza tampoco.
Pg. 7
1 OE (una asignacin)
2 OE
4 OE
funcin)
1 OE (un retorno)
1 OE (un retorno)
Pg. 8
1 OE (una asignacin)
2 OE
2 OE
funcin)
1 OE (un retorno)
1 OE
(una asignacin)
2 OE
4(n-1)+4 OE
2(n-1) OE
(Se ejecutan
2 operaciones en cada
1 OE (un retorno)
T(n) 1 2 ( 4 2 ) 4 2 1 6n 4 OE
i 1
3ro
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:
Docente: Ing. Erech Ordoez Ramos
Pg. 9
i n
i 0
n 1
2
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:
T(n)
10n 2
2n
3
Read(n)
s=0
i=1
While(i<=1) do
s=s+1
i=i+1
End(While)
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.
1.
2.
3.
4.
5.
6.
7.
8.
Read(n)
s=0
i=1
While(i<=1) do
s=s+1
i=i+1
End(While)
Write(n,s)
5 OE
Pg. 10
read(n)
s=0
i=1
while(i<=1) do
s=s+1
i=i+1
end(while)
write(n,s)
1 OE
1 OE
1 OE
1n +1 OE (n vueltas + 1 evaluacin de salida)
2n OE
2n OE
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.
2.
3.
4.
5.
6.
7.
8.
Read(n)
s=0
i=1
While(i<=1) do
s=s+1
i=i+1
End(While)
Write(n,s)
1 OE
1 OE
1 OE
1n/2+1 OE
2n/2 OE
2n/2 OE
1 OE
t(n) =
5n/2+5 OE
Read(n)
s=0
i=1
While(i<=1) do
s=s+1
i=i+1
End(While)
Write(n,s)
Pg. 11
a. Mejor Caso: En el mejor de los casos no entra en el bucle While por lo cual se
ejecutan las siguientes operaciones elementales.
1.
2.
3.
4.
5.
6.
7.
8.
Read(n)
s=0
i=1
While(i<=1) do
s=s+1
i=i+1
End(While)
Write(n,s)
5 OE
read(n)
s=0
i=1
while(i<=1) do
s=s+1
i=i+1
end(while)
write(n,s)
1 OE
1 OE
1 OE
1n +1 OE (n vueltas + 1 evaluacin de salida)
2n OE
2n OE
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.
2.
3.
4.
5.
6.
7.
8.
Read(n)
s=0
i=1
While(i<=1) do
s=s+1
i=i+1
end(while)
Write(n,s)
1 OE
1 OE
1 OE
1n/2+1 OE
2n/2 OE
2n/2 OE
1 OE
t(n) =
5n/2+5 OE
Pg. 12
En adelante consideraremos solo el caso peor por ser de mayor representatividad para
nuestros fines.
Read(n)
S=0
While n>1 do
S=S+1
n=n/2
End(while)
Write (n,S)
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:
Pg. 13
1.
2.
3.
4.
5.
6.
7.
Read(n)
S=0
While n>1 do
S=S+1
n=n/2
End(While)
Write (n,S)
1 OE
1 OE
(Log2n)+1 OE
2*(Log2n) OE
2*(Log2n) OE
1 OE
t(n) = 5 Log2n+3
Read(n)
S=0
While n>1 do
S=S+1
n=n/3
End(While)
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.
Por lo tanto dependiendo por cuanto es dividido la variable controladora de un bucle,
obtendremos Log x n vueltas.
Ahora si analicemos nuestro algoritmo lnea por lnea, incluyendo las vueltas del
bucle, obtenemos:
1.
2.
3.
4.
5.
6.
7.
Read(n)
S=0
While n>1 do
S=S+1
n=n/3
End(While)
Write (n,S)
1 OE
1 OE
(Log3n)+1
2*(Log3n)
2*(Log3n)
1 OE
t(n) = 5 Log3n + 3
Pg. 14
1. for i:=1 to n do
2. begin
3. end;
i=1
1OE
While i<=n do 1OE
Begin
i:=i+1;
2OE
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.
Pg. 15
1. n:=Length(lista);
2. for i:=0 to n-1 do
3. begin
4. for j:=0 to n-1 do
5. begin
6.
if lista[i]>lista[j] then
7.
begin
8.
aux:=lista[i];
9.
lista[i]:=lista[j];
10.
lista[j]:=aux;
11. end;
12. end;
13. end;
2 OE
(4+1)n +1OE multiplicado por n vueltas
((4+1)n+1) n OE
3n2 OE
2 n2 OE
3 n2 OE
2 n2 OE
t(n) = 15n2+6n+3
Asntotas
Como vimos anteriormente podemos calcular el tiempo terico t(n) de cualquier
algoritmo el cual nos ha de permitir comparar la potencia de dicho algoritmo
independientemente de la potencia de la mquina que los ejecute e incluso de la habilidad
del programador que los codifique. Por otra parte, de este anlisis nos interesa
especialmente cuando el algoritmo se aplica a problemas grandes. No debe olvidarse que
cualquier tcnica de ingeniera, que funciona, acaba aplicndose al problema ms grande
que sea posible: las tecnologas de xito, antes o despus, acaban llevndose al lmite de
sus posibilidades.
Pg. 16
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:
g IN O(f(n))
Pg. 17
a)
f(n) IN O(g(n))
f(n) IN O(f(n))
b)
f(n) IN O(h(n))
O(f(n)) = O(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:
c)
lim ()/() =
f(n) IN O(g(n))
g(n) NOT_IN O(f(n))
O(f(n)) es subconjunto de O(g(n))
d)
lim ()/() =
f(n) IN O(g(n))
g(n) IN O(f(n))
O(f(n)) = O(g(n))
e)
lim ()/() =
Ejemplo:
1. Demostrar que la funcin f (n) 0,01n no pertenece a O(n )
3
Para demostrar que f(n) no es de orden cuadrtico basta tener en cuenta que:
0,013
2
lim
= lim 0.01 =
Pg. 18
2 +5
2+1
==
3 +22
3 2 +2
= 6 = = 0
3. Sea = 2 + 5 y = 2
Entonces lim () =
2 +5
2
==
2 +5
2+1
2
=2=1
Para demostrar que f(n) es de orden cuadrtico basta tener en cuenta que:
+
lim
= lim
Pg. 19
rdenes de complejidad
Se dice que O(f(n)) define un "orden de complejidad". Escogeremos como
representante de este orden a la funcin f(n) ms sencilla del mismo. As tendremos:
O(1)
orden constante
O(log n)
orden logartmico
O(n)
orden lineal
O(n log n)
O(n2)
orden cuadrtico
O(na)
O(an)
O(n!)
orden factorial
Pg. 20
El caso base, que maneja una entrada simple que puede ser resuelta sin una
llamada recursiva
Ejemplo:
0! = 1
n! = n * (n-1)!
si n>0
Pg. 21
a)
b)
c)
Pg. 22
mcd (a-b, b)
mcd (a, b-a)
a
si a > b
si a < b
si a = b
Ecuaciones de Recurrencia
En un algoritmo recursivo, la funcin que establece su tiempo de ejecucin
viene dada por una ecuacin de recurrencia, donde en la expresin aparece la propia
funcin
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
El +1 corresponde a mover el disco ms grande de A a C, cada t(n-1) corresponde a
Docente: Ing. Erech Ordoez Ramos
Pg. 23
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
Aqu ya es posible notar que t(n)+1 = 2n o bien que t(n) = 2n 1. Esto en
principio es slo una especulacin y debemos ser capaces de probar que lo que
decimos es cierto. Esto se puede hacer por induccin sobre n.
Pg. 24
t(n) = 2 t(n1) + 1 es
t(n) = 2n 1.
t(n + 1)
= 2 t(n) + 1
(2)
t(n + 1)
= 2(2n 1) + 1
(3)
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:
int Fact (int n)
{
if (n <= 1)
return(1);
else
return( n * Fact(n-1));
}
Sea () el tiempo de ejecucin en el caso peor. Se escribe una ecuacin de
Pg. 25
1
> 1
funcin return(1);
> 1: tiempo requerido por Fact puede dividirse en dos partes:
(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)
Pg. 26
3.
A)
Primera forma
Este mtodo se aplica para ecuaciones de la forma:
() = ( 1 , 2 , , , )
Un ejemplo muy conocido son los nmeros de Fibonacci, cuya ecuacin es:
() = 1 + 2
(6)
2 = + 1
(7)
2 1 = 0
(8)
Pg. 27
1 =
1+ 5
1 5
, 2 =
2
2
= 1 + 2
1 = 2
Ahora, al reemplazar en la segunda condicin inicial, consideraremos 1 = 2 .
t(1) = 1
= 1 1 + 1 2
1
= 1 1 2
= 51
1 =
1
5
B)
1
5
1+ 5
2
1 5
Segunda Forma
Pg. 28
0.
Teorema: La solucin para la ecuacin = 1 + es:
= +
=+1
1 =
(() (1) ) =
=+1
=+1
=+1
Obteniendo finalmente:
=+1
Pg. 29
= 1 + 1, 0 = 0
=0+
1
=1
C)
( 1)
2
Tercera forma
con 0.
+
=+1
Notamos que
1
1
1
+
. Si definimos =
+
=+1
Pg. 30
= +
=+1
= () +
=+1
= 2(1) + 1,
=0
La solucin es:
= 2 .
+
=1
D)
=2 1
Cuarta Forma
Finalmente, para las ecuaciones de la forma = ( ) + obtendremos
como solucin:
()
()
(1) +
= , 1
=1
+ ( )
Pg. 31
= 0 +
=1
Finalmente, = , =
= log b () (1) +
log b
( )
=1
= 2
+ ,
=0
=2
2 ()
2 2
1 +
=1
2 ()
2 2
=1
= 2 2
= 2 ()
+ 1,
=1
= 1 2 ()
1 2
+
=1
2 ()
1
=1
= 1 + 2 ()
Pg. 32
Bibliografa
Pg. 33