Dr. J.B. Hayet

Algorıtmica (1): Analisis de complejidad

Dr. J.B. Hayet

CENTRO DE INVESTIGACION EN MATEMATICAS

Septiembre 2013

,J.B. Hayet Programacion, Septiembre 2013 1 / 43

Outline

1 Complejidad y notacion asintotica

2 Analisis de complejidad


Complejidad y notacion asintotica

Outline





Complejidad

Para poder caracterizar implementaciones: aislar la o las“variables” que permiten caracterizar la complejidad delproblema que resolver, para expresar la complejidad de losoperaciones. Tıpicamente, un numero de elementos dentro delcontenedor. . .

Ejemplos:

Pila.

Cadena de caracteres.

Grafo.



Complejidad en espacio

La primera manera de caracterizar una implementacion es enterminos de la memoria que requiere (espacio): una funcionM(n), caracterıstica del algoritmo, en funcion deltamano de los datos (n), que permite evaluar la cantidadde memoria requerida para usar el algoritmo.



Complejidad en tiempo

Es una funcion T (n) que describe el comportamiento delalgoritmo en cuanto a su tiempo de ejecucion, en terminosde n, el tamano de los datos de input al algoritmo. . .

Se expresa esta funcion T (n) de manera exacta si posible, enterminos de las operaciones elementales (operacionesaritmeticas, operaciones de asignacion, de dereferenciacion), y no enterminos de tiempo absoluto. . . Lo que nos interesa es la tasa decrecimiento, la tendencia cuando n es grande.




Aunque una operacion elemental puede ser mas costosa en tiempoque otra, por ejemplo, no considerar la constante multiplicativa quehay entre los dos. En cambio, se considera la complejidad enterminos de numero total de operaciones elementales.

void Ex1 ( i n t n ) i n t i , j ;i n t sum=0,summ=0, l i m i t=n∗n ;f o r ( i =1; i< l i m i t ; i++)

++sumf o r ( j =1; j<sum ; j++)

++summ;




En el ejemplo:

T (n) = 4 + 1 + n2 + 2(n2 − 1) + 1 + n2 − 1 + 2(n2 − 2)= 6n2 − 1

Aquı lo que nos importa realmente es sobre todo que secomporta como n2 para grandes valores de n.




A veces no se puede establecer una forma exacta o aun aproximadade T (n), sino expresarla estadısticamente:

en promedioen el peor de los casos

Ejemplo: busqueda en un quadtree.



Gran O

Como lo que nos interesa es el comportamiento asintotico delas complejidades, se usa herramientas para comparar esoscomportamientos cuando n→∞.Dadas dos funciones T y U de N en R, se dice queT (n) = O(U(n)) ssi existe un real c > 0 y un entero n0tal que ∀n ≥ n0, T (n) ≤ cU(n)

T (n)

U(n)



Gran O

4n

2n + 4 2n + 4

n n

8n

T (n) = 2n + 4 = O(n)



Gran O

La notacion gran O define una cuota superior a unafuncion y una familia de tendencia de crecimiento.

T (n) = O(U(n)) significa que el crecimiento de T esinferior o igual al de U para grandes valores de n.

Se puede comparar funciones:

1 ≤ log n ≤ n ≤ n log n ≤ n2 ≤ 2n ≤ nn.

Las constantes multiplicativas no cuentan.



Gran O

Si T (n) es un polinomio de grado g , T (n) = O(ng): sepuede “olvidar” los terminos de grado inferior y las constantes.

Usar la clase de funciones mas chica: 2n es O(n) (no sedice, aunque es cierto, que es O(n2)).

Usar la expresion mas simple: no se dice que 2n es 12n.



Gran O

Propiedad: suma y producto.Si T1(n) = O(U1(n)) y T2(n) = O(U2(n)), entoncesT (n) = T1(n) + T2(n) = O(max(U1(n),U2(n))).Si T1(n) = O(U1(n)) y T2(n) = O(U2(n)), entoncesT (n) = T1(n)T2(n) = O(U1(n)U2(n)).

Prueba:∃ (c1 > 0,n1

0) / ∀n ≥ n10, T1(n) ≤ c1U1(n)

∃ (c2 > 0,n20) / ∀n ≥ n2

0, T2(n) ≤ c2U2(n)entonces :∀n ≥ max(n1

0, n20), T (n) ≤ (c1 + c2) max(U1(n),U2(n))

∀n ≥ max(n10, n

20), T (n) ≤ c1c2U1(n)U2(n)



Gran O

Propiedad: suma y producto.Si T1(n) = O(U1(n)) y T2(n) = O(U2(n)), entoncesT (n) = T1(n) + T2(n) = O(max(U1(n),U2(n))).Si T1(n) = O(U1(n)) y T2(n) = O(U2(n)), entoncesT (n) = T1(n)T2(n) = O(U1(n)U2(n)).


0) / ∀n ≥ n10, T1(n) ≤ c1U1(n)

∃ (c2 > 0,n20) / ∀n ≥ n2

0, T2(n) ≤ c2U2(n)entonces :∀n ≥ max(n1

0, n20), T (n) ≤ (c1 + c2) max(U1(n),U2(n))

∀n ≥ max(n10, n

20), T (n) ≤ c1c2U1(n)U2(n)



Gran O

Propiedad: transitividad.Si T (n) = O(U(n)), y U(n) = O(W (n)), entoncesT (n) = O(W (n)).


0) / ∀n ≥ n10, T (n) ≤ c1U(n),

∃ (c2 > 0,n20) / ∀n ≥ n2

0, U(n) ≤ c2V (n),entonces ∀n ≥ max(n1

0, n20), T (n) ≤ c1c2V (n)



Gran O

Propiedad: transitividad.Si T (n) = O(U(n)), y U(n) = O(W (n)), entoncesT (n) = O(W (n)).


0) / ∀n ≥ n10, T (n) ≤ c1U(n),

∃ (c2 > 0,n20) / ∀n ≥ n2

0, U(n) ≤ c2V (n),entonces ∀n ≥ max(n1

0, n20), T (n) ≤ c1c2V (n)



Gran O

Propiedad: base de logaritmo y O.loga n = O(logb n) para cualquieros a, b > 1. Eso significa queasintoticamente, no importa la base del logaritmo, de lamisma manera que no importa un factor multiplicativo en unapotencia constante de n. Se podra usar base 2, e o 10.

Prueba:loga n = 1

logb alogb n.



Gran O

Propiedad: base de logaritmo y O.loga n = O(logb n) para cualquieros a, b > 1. Eso significa queasintoticamente, no importa la base del logaritmo, de lamisma manera que no importa un factor multiplicativo en unapotencia constante de n. Se podra usar base 2, e o 10.

Prueba:loga n = 1

logb alogb n.



Gran omega

Se dice que T (n) = Ω(U(n)) ssi existe un real c > 0 yun entero n0 tal que ∀n ≥ n0, T (n) ≥ cU(n).

Establece una cuota inferior a T (n). Es equivalente aU(n) = O(T (n)): si existe n0 y c > 0 tal que T (n) ≥ cU(n),U(n) ≤ 1

cT (n).

Las propiedades de O valen para Ω (transitividad, polinomios,producto), y el max se hace min en la propiedad relativa a la suma.



Gran theta

Se dice que T (n) = Θ(U(n)) ssi T (n) = O(U(n)) yT (n) = Ω(U(n)).

Establece la equivalencia de comportamiento de dos funciones paragrandes n. Lo que nos interesara particularmente es la cuotasuperior.



Mas propiedades

Se puede escribir que T (n) = O(U(n)) si limn→∞T (n)U(n) es

una constante positiva.

Prueba: si el limite es c , existe n0 tal que |T (n)U(n)− c | < 1

2, lo que

implica T (n)U(n)

< c + 12

para n ≥ n0,

T (n) < (1

2+ c)U(n)

Se puede escribir que T (n) = Θ(U(n)) si limn→∞T (n)U(n) es

constante positiva no nula.

Prueba: igual, pero implica T (n)U(n)≤ 3c

2, y T (n)

U(n)≥ c

2



Mas propiedades

Dominaciones:

nk = O((1 + ε)n)) para todo k > 0 y todo ε > 0: unpolinomio es dominado por una exponencial, incluso con unapotencia arbitrariamente pequena.

(log n)k = O(nε) para todo k > 0 y todo ε > 0: unlogaritmo es dominado por una potencia, incluso de factoresarbitrariamente pequenos.


Analisis de complejidad

Outline





Analisis: el por que

Antes de optimizar cualquiera cosa en su programatecnicamente, es importante determinar cual es la complejidad delalgoritmo subyacente!

elecciones algorıtmicas cambian el comportamientoasintotico de la funcion de complejidad: n, n log n, n2. . .

optimizaciones en el codigo “solo” cambian constantes ofactores multiplicativos a este comportamiento asintotico:n2

, 4n. . .



Limites de la analisis

A veces se tiene que relativizar las relaciones de dominaciona traves del O: si tengo dos algoritmos para una funcionalidaddada y que

T (n) = 1000000n

U(n) = n1210 ,

aunque T (n) esta dominado por U(n), el comportamiento de Upuede ser preferible en la gran mayorıa de los casos!



Ejemplo 1: ordenamiento por seleccion

Ordenar un arreglo de enteros, por seleccion: se cambia el valorexaminado por el mınimo de los que siguen

index 0 1 2 3 4 5 6 accion

-----------------------------------------------------------------

| 4 0 3 6 1 8 5

it=0 | 0 4 3 6 1 8 5 swap 0,4

it=1 | 0 1 3 6 4 8 5 swap 1,4

it=2 | 0 1 3 6 4 8 5 -

it=3 | 0 1 3 4 6 8 5 swap 4,6

it=4 | 0 1 3 4 5 8 6 swap 5,6

it=5 | 0 1 3 4 5 6 8 swap 6,8

Complejidad?




// Search f o r min between s t a r t and endi n t minIndex ( i n t ∗ tab , i n t s t a r t , i n t end )

i n t im in = s t a r t ;f o r ( i n t i=s t a r t +1; i<end ; i++)

i f ( tab [ i ] < tab [ im in ] )im in = i ;

return im in ;// Swap i and jvoid swap ( i n t ∗ tab , i n t i , i n t j )

i n t t = tab [ i ] ;tab [ i ] = tab [ j ] ;tab [ j ] = t ;




La funcion principal:

void s e l e c t S o r t ( i n t ∗ tab , i n t n e l s ) f o r ( i n t i =0; i<ne l s −1; i++)

swap ( tab , i , min Index ( tab , i , n e l s ) ) ;

En cada elemento del recorrido, se cambia el valor por el valorminimo encontrado al recorrer el final del arreglo.




Complejidad T (n):

T (n) =n−2∑i=0

(Tswap + TminIndex(tab,i ,n)),

swap se hace en tiempo constante, con 4 accesos al arreglo,3 asignaciones (7).

minIndex depende del rango de los indices.




El metodo minIndex :

terminos constantes: 3 (2 asignaciones y una adicion),

terminos hechos (end − start) veces: la comparacion,

terminos hechos (end − start − 1) veces: una incrementacion,dos accesos a arreglo y una comparacion,

queda el termino hecho en caso de que la condicion es true, 1asignacion. En el caso peor, estara true en todos casos.

En el peor de los casos:

TminIndex(tab,i ,n) = 3 + (n − i) + 5(n − i − 1)= 6n − 6i − 2



Ejemplo 1: ordenamiento por selecion

En total:

T (n) =∑n−2

i=0 (Tswap + TminIndex(tab,i ,n))

= 7(n − 2) +∑n−2

i=0 (6n − 6i − 2)

= 7(n − 2) + (n − 1)6n − 2(n − 1)− 6∑n−2

i=0 i= 6n2 − n − 12− 3(n − 2)(n − 1)= 3n2 − 10n − 18

Entonces el algoritmo es cuadratico en el peor caso:T (n) = O(n2), no es muy eficiente para grandes valores de n. ¿En elmejor?



Ejemplo 2: mergeSort

Otro algoritmo famoso para ordenamiento: el mergeSort.

Adopta el divide-and-conquer para el ordenamiento en sitio:

void mergeSort ( i n t ∗ tab , i n t s t a r t , i n t end , i n t p i v o t )i f ( s t a r t == end ) return ;e l s e

// Pr imera pa r t emergeSort ( tab , s t a r t , p i vo t , ( s t a r t+p i v o t ) / 2 ) ;// SegundamergeSort ( tab , p i v o t +1,end , ( p i v o t+end+1)/2) ;

// Combinar l o s a r r e g l o smerge ( tab , s t a r t , end , p i v o t ) ;




void merge ( i n t ∗ tab , i n t s t a r t , i n t end , i n t p i v o t ) i n t tmptab [ end−s t a r t +1] ;i n t i=s t a r t , j=p i v o t +1,k=0;f o r ( ; j<end && i<p i v o t +1;)

i f ( tab [ j ]<=tab [ i ] )tmptab [ k]= tab [ j++]

e l s etmptab [ k]= tab [ i ++]

k++;f o r ( ; j<end ; j++) tmptab [ k++]=tab [ j ++];f o r ( ; i<p i v o t +1; j++) tmptab [ k++]=tab [ i ++];f o r ( i=s t a r t , k=0; i<end ; ) tab [ i++]=tmptab [ k++];




En el primer ciclo, una vez cada de los elementos de tab,excepto los que vienen en el ciclo final.

En total, Tmerge(n) = O(n) donde n = end − start + 1.

Luego, observar que el algoritmo es recursivo, entonces, encada nivel, tenemos dos instancias del problemaoriginal, pero con tamano de dato dividido por dosEn el caso que n = 1, salimos directamente despues de lacomparacion: T (1) = 1




En consecuencia, se puede escribir:T (1) = 1T (n) = 2T (n

2) + O(n)

≤ 2T (n2

) + cn

expresando la complejidad de manera recursiva.

Solucion?




Poner n = 2i y U(i) = T (n), la relacion se hace:

U(0) = 1U(i) = 2U(i − 1) + c2i

= 4U(i − 2) + c(2i + 2.2i−1)= 8U(i − 3) + c(2i + 2.2i−1 + 222i−2)

...= 2iU(0) + ci2i .

EntoncesT (n) = n(1 + c log n) = O(n log n).

El algoritmo de mergeSort es en n log n.



Ejemplo 3: busqueda por dicotomıa

b o o l s e a r c h ( i n t ∗ tab , i n t v a l , i n t s t a r t , i n t end , i n t &i n d ) i f ( end==s t a r t )

i f ( tab [ s t a r t ]== v a l ) i n d=s t a r t ;r e t u r n t r u e ;

e l s e r e t u r n f a l s e :i n t p i v o t =( s t a r t+end ) / 2 ;i f ( v a l<tab [ p i v o t ] )

r e t u r n s e a r c h ( tab , v a l , s t a r t , p i v o t , i n d ) ;e l s e i f ( v a l>tab [ p i v o t ] )

r e t u r n s e a r c h ( tab , v a l , p i v o t +1,end , i n d ) ;e l s e

i n d=p i v o t ;r e t u r n t r u e ;



Ejemplo 3: busqueda por dicotomıa

En un arreglo ordenado, la complejidad de una busqueda es de ordenO(log n): todos los datos pueden estar vistos como un arbol binarioconteniendo todos los enteros. El algoritmo solo busca un camino dela raız hasta una hoja (y uno solo).

T (n) = O(log n).



Complejidades usuales

O(1): complejidad constante. Occure cuando instruccionesson ejecutadas una y una vez solamente, independientementedel tamano del problema

O(log n): complejidad logarıtmica, que crece ligeramente conn. Problemas de dicotomıa, tıpicamente, donde el problema escompartido en varias instancias y solo una esta procesada.

O(n): complejidad lineal. Problemas con ciclos sobre los datoscon procesamiento de duracion constante. . .

O(nlog(n)) : complejidad n-logarıtmica. Problemas donde encada iteracion se divide en sub-problemas, donde elprocesamiento es lineal (mergeSort, quickSort)



Complejidades usuales

O(n2): complejidad cuadratica. Caso de tos los algoritmosque implica dos ciclos imbricados, donde el ciclo interno se hacesobre todos los datos o aun sobre un numero de datos lineal enel index del primer ciclo

O(n3): complejidad cubica, implica generalmente tres ciclosimbricados

O(2n): complejidad exponencial, eso corresponde aalgoritmos ingenuos, que a partir de ciertos tamanos no muyaltos son completamente inutilisables



Complejidad del problema

Hasta ahora solo hemos analizado la complejidad de soluciones aunos problemas; para varios problemas (como el ordenamiento), hayvarios tipos de soluciones de complejidad diferente, pero ningunopuede llegar abajo de cierto nivel: se habla de complejidadintrınseca al problema (la complejidad del mejor algoritmoque puede solvarlo).




Unas nociones importantes:

problemas: decision / optimizacion/ ...,

maquinas deterministas (Turing): hacen una instruccion a lavez, corresponden al modelo teorico clasico para las maquinasactuales,

maquinas no-deterministas: maquinas teoricas, que tendrıan laposibilidad, frente a una situacion en que hay que explorarvarias posibilidades, de explorarlas “a la vez”.




Clases de problemas:

L: problemas que pueden estar resueltos en tiempo logarıtmico.

P: problemas que pueden estar resueltos en tiempo polinomial(problemas “faciles”).

NL: problemas que pueden estar resueltos por un algoritmo enuna maquina no determinista en tiempo logarıtmico.

NP: problemas que pueden estar resueltos por un algoritmo enuna maquina no determinista en tiempo polinomial.



Complejidad del problema: problemas NP

Problemas combinatorios.

Implican una enumeracion de posibilidades que hay queexaminar.

Son equivalente a problemas de decision que, si se da unasolucion candidata, se puede contestar en tiempo poliniomialque si o no.

NP-dificil: los mas difıciles, aun, todo problema NP se puedereducir polinomialmente en uno de esos.



Complejidad del problema: problemasNP-dificil


Documents

Dr. J.B. Hayet