U. A. G. R. MUNIVERSIDAD AUTONOMA GABRIEL

RENE MORENO

Facultad Ciencias de la computaciónCarrera de Sistemas

Semestre I/2015

Apuntes 1 : Complejidad Algorítmica.

Ing. Mary López N.

Cap1.3 Análisis Algorítmico página 1

Fundamentos Teóricos1.Ejemplos step by step2.Análisis de Algoritmos que llaman a otros algoritmos3.Ejercicios Resueltos4.

BIBLIOGRAFIA

Eugenio Scalise, Rhadamés Carmona; “Análisis de algoritmos y complejidad”1.

Brassard Bratley; “Fundamentos de Algoritmia”2.

REFERENCIAS BIBLIOGRAFICAS EN LA WEB

1. Blog de la materia

2. Manual de análisis y diseño de algoritmos.

Indice

Cap1.3 Análisis Algorítmico página 2

Contador de Frecuencias = T(n) = Contar el número de instrucciones que ejecuta el algoritmoi.Calculo del Running Time => Conteo de instrucciones elementales para un tamaño de entrada N.a.

Caso Mejor (Omega) Ω (n) --> Busca el menor número de instrucciones 1)Caso Medio (Teta) ϴ (n) --> Promediar el numero de instrucciones2)Caso Por (Big O) (n) --> Máximo numero de instrucciones3)

Factor de Crecimiento i.Determinar la Complejidad Algorítmica => Es decir el Rendimiento.b.

El Análisis Algorítmico consisten en 1.

Constante => O(1)a.Logarítmico => O(ln N)b.Líneal => O(N)c.Logarítmico lineal => O(N ln N)d.Cuadrático => O(N2)e.Cubico => O(N3)f.Polinomio => O(NM)g.Exponencial =O(2N)h.Factorial =O(N!)i.

Notación Asintótica => Familia de relaciones de Landao para representar el tiempo de ejecución de los algoritmos:

2.

Como Calcular el Tiempo de Ejecución T(n)3.Realizar el conteo de frecuencias tomando en cuenta la notación asintótica

Asignar, Leer, Mostrar, => 1i.

Sentencia Simple a.

Si condicional b.O(T(Si−Entonces−Sino))=O(T(condición))+Máx.(O(T(Entonces)),O(T(Sino)))Ω(T(Si−Entonces−Sino))= Ω(T(condición))+MIN( Ω(T(Entonces)), Ω(T(Sino)))

if (a>b)

suma =0;

s=pow(suma * x),2)

else

suma =1;

Ciclos o Buclesc.

Ponderar cada línea según :

i.

Fundamentos Teóricos

Cap1.3 Análisis Algorítmico página 3

ii.

iii.

iv.

v.

La variable se duplica o divide en cada paso. --> O(log n)

Cap1.3 Análisis Algorítmico página 4

vi.

El algoritmo dentro del BUCLE se repite Log N. --> O( n log n)

Sumar todas las líneas obteniendo una expresión algebraica que represente el conteo total.4.

Serie Aritmética => Aplicar para Ciclos anidadosa.

K = ?

Otras Series => Se las puede determinar utilizando teoría de SUMATORIOSb.

Propiedades de las sumatoriasc.Entre las propiedades generales de las sumatorias reportadas en la literatura se encuentra las once que se relacionan a continuación, cuya demostración se realiza utilizando el procedimientomatemático de Inducción Completa.

Propiedad #1:

Propiedad #2:

Cap1.3 Análisis Algorítmico página 5

Propiedad #3:

Propiedad #4:

Propiedad #5:

N I J Nro. Comparaciones

j

Nro.Incrementos

j

Nro. Comparaciones

i

Nro.Incrementos

i

4 1 1 0+1+1 =2 1 4 3

2 0 0+1+1+1=3 2

3 2 0+1+1+1+1=4 3

4 1

0

3

2

1

0

N = 4 Total = 9 Comparaciones

TOTAL = 6 Incrementos

El Numero de entradas N es 4i.

i= 1 -> 2 comparaciones de Ji= 2 --> 3 comparaciones de ji= 3 --> 4 comparaciones de j

Para N=4 se hicieron 9 comparaciones . Este conteo resulta de la sumatoria de las

comparaciones de J por cada Ciclo de la variable iii.

((2+4)/2)*3 = 9Luego la formula ((Pri+Ulti)/2)*Nro Elementos

((2+N+1)/2)*(N) = ((N+3)/2)*NEntonces Comparaciones de J para nuestro caso de estudio

((1+N)/2)*(N) = ((N+1)/2)*NEntonces Incrementos de J para nuestro caso de estudio

Series generadas por conteos. Obsérvese la siguiente tabla generada por la prueba de escritorio realizada en el algoritmo de Ordenación por Inserción

d.

Series generadas por conteo. Obsérvese este otra tabla generada por la prueba de escritorio en un e.

Cap1.3 Análisis Algorítmico página 6

Series generadas por conteo. Obsérvese este otra tabla generada por la prueba de escritorio en un algoritmo X. que genera:

e.

N i j k Incrementos j Comparac J Incremen K Comparac k5 1 2 -->2 5 4 3 2 4 3 2 1 14 12 9 5 18 15 11 6

3 -->3 2 3 4 5 1 2 3 4 5 9 12 14 6 11 15 18

4 -->4 =(2+5)*4/2 =(1+4)*4/2

5 -->5 =(2+n+1)*n/2 =(1+n)*n/2

6 =(3+n)*n/2

2 3 -->3 Aquí N = número de elementos de la serie (4)

Aquí N = número de elementos de la serie (4)

4 -->4

5 -->5

6

3 4 -->4

5 -->5

6

4 5 -->5

6

5

Analizando incrementos de K

Se ha formado una serie NO ARITMETICA : 5 9 12 14

Serie Cuadrática An2 + bn + c

a+b+c --> n=14a+2b+c --> n=29a+3b+c --> n=3a+b+c 4a+2b+c 9a+3b+c

Luego reemplazando en la ecuacion An2 +bn + c

- - 3a+b 5a+b

-

2a

5 9 12 14

-1 -1

4 3 2

2a=-1 --> a=-1/2

Cap1.3 Análisis Algorítmico página 7

2a=-1 --> a=-1/23a+b = 4 --> b=11/2a+b+c =5 --> c=0

-1/2 n^2 +11/2 n

Luego : An^2 +bn +c

Sumando Todo :

-1/2 (n(n+1)(2n+1)/6) + 11/2 (n(n+1)/2) =-1/12 (2n^3 +3n^2 +n) + 11/4(n^2+n) =(-2n^3 -3n^2-n+33n^2+33n)/12 =(-n^3+15n^2+16n) / 6

O(Max(f(n),g(n)))Regla de la Suma => Al observar los tiempos de ejecución Seleccionar el MAXa.

Regla del Producto => Aplicar para ciclos Anidadosb.• Si: T1(n) y T2(n) son tiempos de ejecución de dos algoritmos A1 y A2.• Donde: T1(n) es O(f(n)) y T2(n) es O(g(n))• Entonces: T1(n)*T2(n) es O(f(n)*g(n)))

Si C es una constante: O(c*f(n)) = O(f(n))

Por ejemplo: O((n2)/2) O(n2)

Constante Multiplicativa => Se la puede ignorar c.

K*n = n => Si K es una constantei.n/K = n => Si K es una constanteii.

Nk + Nz = Nk => Si K es mayor que Ziii.

Nk + Nz = Nz => Si Z es mayor que kiv.

En Resumen al simplificar para obtener la complejidad no olvidard.

Llamadas a procedimientos e.La complejidad de la llamada a un procedimiento será igual a la complejidad del procedimiento.

Int calcula() int x=2*5; 1return x; 1

Void main() int a=0; 1 int b=calcula(); 2 count<< b; 1

// Calcula es 2

//Conteo total seria 4

Simplificar la expresión asintótica5.

Cap1.3 Análisis Algorítmico página 8

Modelo 1 : Midiendo cada Instrucción por conteo1.

Modelo 2: Simplificando instrucciones Simples (Recomendado)2.

Modelo 3 : Midiendo cada Instrucción por sumatorios (Para ciclos de más de 2 anidados)3.

Ejercicios4.

Analizar los 3 casos a veces no aplica a.

RECUERDE !

IF WHILEAl analizar caso mejor, peor o medio la diferencia esta usualmente en las PREGUNTAS (comparaciones)

CASO PEOR se saca un T(N)-

CASO MEJOR se saca otro T(N)-

Recordar que al analizar :

Ejemplos step by step

Cap1.3 Análisis Algorítmico página 9

int Buscar(int *a, int c)

j=1; WHILE (a[j]<c) && (j<n) j:=j+1 ;

RETURN j ;IF a[j]== c

ELSE RETURN 0 ;

int j;

;

CASO MEJOR (Omega Ω)1=1 1.(1+1) = 2 (Solo hace la primer comparacion)2.

0 (Entra al ciclol 0 veces)3.(1+1) = 2 4.15. Min(1,1) --> 116.================================

T(n) = 6 => Ω(1)

CASO PEOR(Big О)1=1 1.

((1+1)+1+1) *n= 4*(n) (Se hacen las N comparaciones)2.

2*(n-1) (Entra al ciclo N-1 veces)3.(1+1) = 2 4.15.

Max(1,1) --> 116.================================

T(n) = 1 + 4n + 2n - 2+ 3 =6n + 2 => О(n)

CASO PROMEDIO (Tita ϴ)1=1 1.(1+1)+1+1 = (4*(n/2)) (La mitad de las comparaciones)2.

2*(n-1)/2 = n-1 (Entra al ciclo (N-1)/2 veces)3.(1+1) = 2 4.15. PROMEDIO(1,1) --> (1+1)/2 = 116.================================

T(n) = 1 + 2n + n -1+ 3 = 3n + 3 => ϴ(n)

CASO MEJOR (Omega Ω)

Asignación =11.

Ubica A[j] y lo compara =1 +12.

Asignación que nunca sucede =03.

Ubica A[j] , lo compara y le suma el costo menor de las líneas 5 y 6 =1 +1 + 1=3

4.

15.

16.

CASO PEOR(Big О)Asignación =11.Ubica A[j] , lo compara 2 veces y hace un AND , todo N veces =1 +2+1=4*n

2.

Asignación y suma N-1 veces = (2*(n-1))3.Ubica A[j] , lo compara y le suma el costo mayor de las líneas 5 y 6 =1 +1 + 1=3

4.

15.16.

CASO PROMEDIO (Tita ϴ)Asignación =11.Ubica A[j] , lo compara 2 veces y hace un AND , todo N/2 veces =1 +2+1=4*n/2

2.

Asignación y suma (N-1)/2 veces = (2*(n-1)/2)

3.

Ubica A[j] , lo compara y le suma el costo promedio de las líneas 5 y 6 =(1 +1)/2 =1

4.

15.16.

Modelo 1 : Midiendo cada Instrucción por conteoviernes, 28 de marzo de 2014 16:51

Cap1.3 Análisis Algorítmico página 10

int Buscar(int *a, int c)int j;j=1; WHILE (a[j]<c) && (j<n) j:=j+1 ;

RETURN j ;IF a[j]== c

ELSE RETURN 0 ;;

CASO MEJOR (Omega Ω)1=1 1.1 = 1 (Solo hace la primer comparación)2.

0 (Entra al ciclol 0 veces)3.(1) = 1 4.15. Min(1,1) --> 116.================================

T(n) = 4 => Ω(1)

CASO PEOR(Big О)1=1 1.1*n = n (Se hacen todas las comparaciones)2.1*(n-1)3.(1) = 14.15. Max(1,1) --> 116.================================

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

CASO PROMEDIO (Tita ϴ)1=1 1.1 * n/2 = (1*(n/2)) (En promedio la mitad de las comparaciones)2.1*(n-1)/2 = 3.(1) = 14.15. PRO(1,1) --> (1+1)/2 = 116.================================

T(n) = 1 + n/2 + n/2 - 1/2+ 2 = n + 5/2 => ϴ(n)

Modelo 2: Simplificando instrucciones Simples a 1viernes, 28 de marzo de 2014 16:51

Cap1.3 Análisis Algorítmico página 11

Ejemplo 11.

Ejemplo 22.

Ejemplo 33.

Ejemplo 4 Caso Especial 14.

Ejemplo 5 Caso Especial 25.

Análisis de Algoritmos que llaman a otros algoritmosjueves, 25 de septiembre de 2014 10:46

Cap1.3 Análisis Algorítmico página 12

<http://www.lab.dit.upm.es/~lprg/material/apuntes/o/>

class Polinomio private double[] coeficientes;Polinomio (double[] coeficientes) this.coeficientes= new double[coeficientes.length]; System.arraycopy(coeficientes, 0, this.coeficientes, 0, coeficientes.length); double evalua_1 (double x) double resultado= 0.0; for (int termino= 0; termino < coeficientes.length; termino++) double xn= 1.0; for (int j= 0; j < termino; j++)

xn*= x; // x elevado a n resultado+= coeficientes[termino] * xn; return resultado;

Si es N el grado del polinomio y es el número de coeficientes. El bucle más exterior (1) se ejecuta N veces. El bucle interior (2) se ejecuta, respectivamente

1 + 2 + 3 + ... + N veces = N*(1+N)/2 => O(n2)

Ejemplo 1: Análisis de Su algoritmosjueves, 25 de septiembre de 2014 10:46

Cap1.3 Análisis Algorítmico página 13

<http://www.lab.dit.upm.es/~lprg/material/apuntes/o/>

double evalua_2 (double x) double resultado= 0.0; for (int termino= 0; termino < coeficientes.length; termino++) resultado+= coeficientes[termino] * potencia(x, termino); return resultado;

private double potencia (double x, int n) if (n == 0) return 1.0; // si es potencia impar ... if (n%2 == 1) return x * potencia(x, n-1); // si es potencia par ... double t= potencia(x, n/2); return t*t;

Si el exponente es par, el problema tiene una evolución logarítmica; mientras que-

si es impar, su evolución es lineal. Si "j" es impar entonces "j-1" es par, el caso peor es que en la mitad de los casos-

tengamos "j" impar y en la otra mitad sea par. El caso mejor, es que siempre sea "j" par.-

Potencia --> Su análisis es algo poco claro.

31 30 15 14 7 6 3 2 1Un ejemplo de caso peor sería x=31, que implica la siguiente serie para j:

2 * eis (log2(j)),cuyo número de términos podemos acotar superiormente por

En el caso mejor visitaremos eis(log2(j)) valores pares de "j"; -

En el caso peor podemos encontrarnos con otros tantos números impares-

entremezclados.

donde eis(r) es el entero inmediatamente superior

Por tanto, la complejidad de Potencia es de orden O(log n).

Insertada la función Potencia en la función EvaluaPolinomio, la complejidad compuestaes del orden

O(n log n), al multiplicarse por N un subalgoritmo de O(log n)

Ejemplo 2: Análisis de Sub algoritmosjueves, 25 de septiembre de 2014 10:46

Cap1.3 Análisis Algorítmico página 14

double evalua_3 (double x) double xn= 1.0; double resultado= coeficientes[0]; for (int termino= 1; termino < coeficientes.length; termino++) xn*= x; resultado+= coeficientes[termino] * xn; return resultado;

Queda en un algoritmo de O(n).

Ejemplo 3: Análisis de Subalgoritmosjueves, 25 de septiembre de 2014 10:46

Cap1.3 Análisis Algorítmico página 15

void calcula (int n) int x=0; while (x <n) x=x+1 ; CalPro(x); return x; T (CalPro(m)) = 5; (caso mejor)T (CalPro(m)) = 4m -5 (caso peor)

Linea x n T(Caso mejor) T(caso peor)

1 0 4 1 1

2 (n+1) (n+1)

3 1 * (n) 1 * (n)

4 5 * (n) 4 (1)-5 = -14 (2)-5 = 34(3)-5 = 7

-1 3 7 n=3

= ((-1 + (4n-5))/2)*n

= 2n2 - 3nEl sumatorio de todas las instrucciones está en la formula 2n2 - 3n

5 1 1

= 3 + 7nΩ(n)

=2n2n+3nΟ( n2)

1234

5

Ejemplo 4: Análisis de Sub algoritmosjueves, 25 de septiembre de 2014 10:46

Cap1.3 Análisis Algorítmico página 16

void calcula (int n) int x=0; while (x <n) CalPro(x); x=x+1 ; return x; T (CalPro(m)) = 5; (caso mejor)T (CalPro(m)) = 4m -5 (caso peor)

Linea x n T(Caso mejor) T(caso peor)

1 0 4 1 1

2 (n+1) (n+1)

3 5 * (n) 4 (0)-5 = -54 (1)-5 = -14(2)-5 = 34(3)-5 = 7

-5 -1 3 7 n=4

= ((-5 + (4(n-1)-5))/2)*n= (2n-7)*n= 2n2-7nEl sumatorio de todas las instrucciones está en la formula 2n2 - 7n

4 1 * (n) 1 * (n)

5 1 1

= 3 + 7nΩ(n)

= 2n+3+2n2-7n = 2n2-5n +3Ο( n2)

1234

5

Ejemplo 5: Análisis de Sub algoritmosjueves, 25 de septiembre de 2014 10:46

Cap1.3 Análisis Algorítmico página 17