Anlisis de Algoritmos y complejidad computacional

Anlisis de Algoritmos y complejidad computacionalIng. Informtico Mitchell Blancas

Facultad de CC.FF. - Escuela de Informtica11Eficiencia de AlgoritmosSiempre que elaboremos un algoritmo debemos preocuparnos en analizar su eficiencia.

Esto implica determinar la cantidad de recursos que utiliza:

Cantidad de memoria Tiempo de cmputo requerido

Estos dos parmetros nos permiten comparar dos algoritmos que resuelven el problema.2Facultad de CC.FF. - Escuela de Informtica2Cantidad de memoriaSe puede determinar fcilmente por el nmero y tamao de las variables.Tiempo de ejecucinSe determina por el nmero de operaciones elementales.Se reduce el espacio de almacenamiento con un incremento del tiempo de ejecucinCompromiso espacio- tiempo3Facultad de CC.FF. - Escuela de Informtica3Medida del Tiempo de EjecucinEl tiempo de ejecucin depende de la cantidad de datos a procesar.

Sin embargo, el tiempo de reloj depende de la velocidad de la mquina, el software que se esta ejecutando (sistema operativo y otros), por lo que no puede ser una medida adecuada.Es por esto que necesitamos una medida independiente de la implementacin, entonces asumimos el modelo de computacin llamado Mquina de Acceso Directo (MAD). Aqu se usan un conjunto bsico de operaciones una detrs de otra, sin operaciones concurrentes (en simultneo).4Facultad de CC.FF. - Escuela de Informtica4Sin usar frmula calcule la suma de los primeros n nmeros naturalesPseudocdigoLeer (n)suma=0Para i=1 hasta i=n suma=suma +iFin paraImprimir (suma)t1 se ejecuta 1 vezt2 se ejecuta 1 vezt3 se ejecuta n vecest4 se ejecuta n veces

t5 se ejecuta 1 vezTiempo total de ejecucin = t1 + t2 + t3.n + t4.n + t5 T(n) = (t1 + t2 + t5)+ (t3 + t4).nNote que los tiempos son valores que se pueden obtener una vez conocida la mquina en la que se ejecutar.

El tiempo total de clculo depende del tamao de la entrada n, sea cual fuera la mquina en la que correr. As que podramos decir que este algoritmo tiene tiempo de ejecucin que depende de n.5Facultad de CC.FF. - Escuela de Informtica5La Notacin AsintticaLa notacin asinttica se emplea para mostrar el comportamiento de una funcin respecto a otra. Adems, puede indicar que dos funciones son aproximadamente iguales o que una crece mas rpidamente que la otra.6Facultad de CC.FF. - Escuela de Informtica6Es una funcin que sirve como cota superior de otra funcin cuando el argumento tiende al infinitoCota superior asinttica

Para expresar la cota superior asinttica de una funcin, se usa la notacin O Grande. Matemticamente:

La Notacin O Grande

La funcin f(x) esta acotada por O( g(x) ), si existe una constante c, a partir de un punto inicial (+), de tal forma que si tomamos cualquier otro punto la funcin f(x) es menor que la otra.7Facultad de CC.FF. - Escuela de Informtica7La Notacin Omega GrandeEs una funcin que sirve como cota inferior de otra funcin cuando el argumento tiende al infinitoCota inferior asinttica

Para expresar la cota inferior asinttica de una funcin, se usa la notacin Grande. Matemticamente:La funcin f(x) esta acotada inferiormente por ( g(x) ), si existe una constante c, a partir de un punto inicial (+), de tal forma que si tomamos cualquier otro punto la funcin f(x) es mayor que la otra.8Facultad de CC.FF. - Escuela de Informtica8La Notacin Theta GrandeEs una funcin que sirve tanto de cota superior como de cota inferior de otra funcin cuando el argumento tiende al infinito.

Cota ajustada asintticaPara expresar la cota ajustada asinttica de una funcin, se usa la notacin Grande. Matemticamente:La funcin f(x) puede ser acotada por ( g(x) ), tanto inferior como superiormente, cuando usamos constantes diferentes.9Facultad de CC.FF. - Escuela de Informtica9

Relaciones entre O, y 10Facultad de CC.FF. - Escuela de InformticaCota Superior asinttica usa notacin O GrandeCota Inferior asinttica usa notacin Omega GrandeCota Ajustada asinttica usa notacin Theta Grande10Reglas para el clculo de complejidadAunque no hay una receta que funcione siempre, daremos algunas pautas de cmo calcular la complejidad de un algoritmo para diferentes casos:

Sentencias Simples Condicionales Bucles Llamadas a funcin Secuencias de instruccionesEntonces pues, dado un programa nos interesa obtener una funcin que represente la cantidad de unidades de tiempo, para luego acotar esta funcin. A esto se le conoce como clculo de la complejidad de un algoritmo.11Facultad de CC.FF. - Escuela de Informtica11a) Sentencias simplesCuando en un algoritmo intervienen sentencias simples, como asignacin, entrada o salida e datos, requieren un tiempo constante de ejecucin por lo que su complejidad ser:O(1)

Esto no incluye aquellas variables cuyo tamao esta relacionado con el tamao del problema.Por ejemplo no puedo considerar la suma de dos nmeros gigantes como sentencia simple.12Facultad de CC.FF. - Escuela de Informtica12b) CondicionalesLa evaluacin de una expresin condicional requiere por lo general un tiempo constante de ejecucin por lo que su complejidad ser O(1).

La complejidad que debe sumarse con la peor de las ramas ya sea las instrucciones a ejecutar de ser verdadera o falsa la condicin.

En decisiones mltiples (else if, switch case) se tomar la peor de las ramas.c) BuclesSi el bucle tiene un contador de tamao conocido entonces se multiplica esa cantidad de veces por la sentencia de peor complejidad.13Facultad de CC.FF. - Escuela de Informtica13d) Llamadas a funcionesViene dada por la complejidad de sus sentencias. El costo de la invocacin a la funcin y su retorno se consideran constantes y se puede obviar para el anlisis asinttico.

El clculo de la complejidad de una funcin se puede complicar si se trata de funciones recursivas, las cuales estudiaremos mas adelante.e) Secuencias de instruccionesLa complejidad de una secuencia de instrucciones es la suma de sus complejidades individuales, debiendo aplicar todo lo anterior.14Facultad de CC.FF. - Escuela de Informtica14O(1) Orden constante O(log n) Orden logartmico O(n) Orden lineal O(n log n) Orden cuasi-lineal O(n2) Orden cuadrtico O(n3) Orden cbico O(na) Orden polinmico O(2n) Orden exponencial O(n!) Orden factorial Jerarqua de Ordenes de Complejidades15O(1): Complejidad constante. Cuando las instrucciones se ejecutan una vez.

O(log n): Complejidad logartmica. Esta suele aparecer en determinados algoritmos con iteracin o recursin no estructural, ejemplo la bsqueda binaria.

O(n): Complejidad lineal. Es una complejidad buena y tambin muy usual. Aparece en la evaluacin de bucles simples siempre que la complejidad de las instrucciones interiores sea constante.

O(n log n): Complejidad cuasi-lineal. Se encuentra en algoritmos de tipo divide y vencers como por ejemplo en el mtodo de ordenacin mergesort y se considera una buena complejidad. Si n se duplica, el tiempo de ejecucin es ligeramente mayor del doble. 16Facultad de CC.FF. - Escuela de Informtica16O(n2): Complejidad cuadrtica. Aparece en bucles o ciclos doblemente anidados. Si n se duplica, el tiempo de ejecucin aumenta cuatro veces.

O(n3): Complejidad cbica. Suele darse en bucles con triple anidacin. Si n se duplica, el tiempo de ejecucin se multiplica por ocho. Para un valor grande de n empieza a crecer dramticamente.

O(na): Complejidad polinmica (a > 3). Si a crece, la complejidad del programa es bastante mala.

O(2n): Complejidad exponencial. No suelen ser muy tiles en la prctica por el elevadsimo tiempo de ejecucin. Se dan en subprogramas recursivos que contengan dos o ms llamadas internas. 17Facultad de CC.FF. - Escuela de Informtica17Facultad de CC.FF. - Escuela de Informtica18

EjemploUn programa emplea 100n unidades de tiempo para ser ejecutado, otro programa emplea 2n2.

Cual de los dos programas es mejor?Depende del tamao del problema.Para n < 50, el programa con tiempo 2n2 es mejor.Para problemas con entrada de datos pequeo, es preferible usar el programa cuyo tiempo de ejecucin es O(n2).Sin embargo, cuando n crece, el programa con tiempo de ejecucin O(n2) emplea mas tiempo que el programa O(n).19Facultad de CC.FF. - Escuela de Informtica19Calculo de la Complejidad en algoritmos iterativosFacultad de CC.FF. - Escuela de Informtica20

funcion( int n) { int i, j, k, x; x=0; para i=1 hasta n-1 hacer para j=i+1 hasta n hacer para k=1 hasta j hacer x = x + 1 }

Calcular la complejidad del siguiente algoritmo iterativo21Facultad de CC.FF. - Escuela de Informtica21funcion( int n) { int i, j, k, x; x=0; para i=1 hasta n-1 hacer para j=i+1 hasta n hacer para k=1 hasta j hacer x = x + 1 }El bucle mas interno repite j veces una instruccin de tiempo O(1) j 1 o sea la instruccin simple x=x+1 se realiza j veces.k=1

El segundo bucle mas interno n j = n (n+1)/2 i (i+1)/2 j=i+1

El tercer bucle (el externo) tenemos n-1 n-1 n-1 [ n (n+1)/2 i (i+1)/2 ] = n (n+1)/2 i (i+1)/2 i=1 i=1 i=1 n-1 = (n-1) n (n+1) / 2 - 1/2 (i2+i) i=1

n-1 = (n-1) n (n+1) / 2 - 1/2 (i2+i) i=1 = (n-1) n (n+1) / 2 - 1/2. (n-1)(n)(2n-1)/6 1/2.(n-1)n/2 = n(n2-1)/3 O(n3)22Facultad de CC.FF. - Escuela de Informtica22Calculo de la complejidad en algoritmos recursivos(RECURRENCIAS)Facultad de CC.FF. - Escuela de Informtica23

Calcular la complejidad del siguiente algoritmo recursivo24Facultad de CC.FF. - Escuela de Informtica

24Calcular la complejidad del siguiente algoritmo recursivo25Facultad de CC.FF. - Escuela de Informtica

Paso1:

25Calcular la complejidad del siguiente algoritmo recursivoT(n) =2 T(n/2)+n

Facultad de CC.FF. - Escuela de Informtica26Calcular la complejidad del siguiente algoritmo recursivoT(n) =2 T(n/2)+n

Facultad de CC.FF. - Escuela de Informtica27Calcular la complejidad del siguiente algoritmo recursivoT(n) =2 T(n/2)+nT(n) = 2[2 T(n/22)+n/2] +n = 22T(n/22)+2n

Facultad de CC.FF. - Escuela de Informtica28Calcular la complejidad del siguiente algoritmo recursivoT(n) =2 T(n/2)+nT(n) = 2[2 T(n/22)+n/2] +n = 22T(n/22)+2n

Facultad de CC.FF. - Escuela de Informtica29Calcular la complejidad del siguiente algoritmo recursivoT(n) =2 T(n/2)+nT(n) = 2[2 T(n/22)+n/2] +n = 22T(n/22)+2nT(n) = 22 [2T(n/ 23) +n/ 22] +2n = 23T(n/23)+3n

Facultad de CC.FF. - Escuela de Informtica30Calcular la complejidad del siguiente algoritmo recursivoT(n) =2 T(n/2)+nT(n) = 2[2 T(n/22)+n/2] +n = 22T(n/22)+2nT(n) = 22 [2T(n/ 23) +n/ 22] +2n = 23T(n/23)+3n...

Facultad de CC.FF. - Escuela de Informtica31Calcular la complejidad del siguiente algoritmo recursivoT(n) =2 T(n/2)+nT(n) = 2[2 T(n/22)+n/2] +n = 22T(n/22)+2nT(n) = 22 [2T(n/ 23) +n/ 22] +2n = 23T(n/23)+3n...T(n) = 2kT(n/2k)+kn ; artificio: 2k =n k= log (n)

Facultad de CC.FF. - Escuela de Informtica32Calcular la complejidad del siguiente algoritmo recursivoT(n) =2 T(n/2)+nT(n) = 2[2 T(n/22)+n/2] +n = 22T(n/22)+2nT(n) = 22 [2T(n/ 23) +n/ 22] +2n = 23T(n/23)+3n...T(n) = 2kT(n/2k)+kn ; artificio: 2k =n k= log (n)T(n) = n*T(1)+ log (n)*n

Facultad de CC.FF. - Escuela de Informtica33Calcular la complejidad del siguiente algoritmo recursivoT(n) =2 T(n/2)+nT(n) = 2[2 T(n/22)+n/2] +n = 22T(n/22)+2nT(n) = 22 [2T(n/ 23) +n/ 22] +2n = 23T(n/23)+3n...T(n) = 2kT(n/2k)+kn ; artificio: 2k =n k= log (n)T(n) = n*T(1)+ log (n)*nT(n) = O(n*T(1)+ log (n)*n) = O (n*log (n))

Facultad de CC.FF. - Escuela de Informtica34Calcular la complejidad del siguiente algoritmo recursivoT(n) =2 T(n/2)+nT(n) = 2[2 T(n/22)+n/2] +n = 22T(n/22)+2nT(n) = 22 [2T(n/ 23) +n/ 22] +2n = 23T(n/23)+3n...T(n) = 2kT(n/2k)+kn ; artificio: 2k =n k= log (n)T(n) = n*T(1)+ log (n)*nT(n) = O(n*T(1)+ log (n)*n) = O (n*log (n))

Facultad de CC.FF. - Escuela de Informtica35