complejidad en tiempo y espacio

Algoritmos y Estructuras de Datos, Universidad Central de Venezuela, Escuela de Computación. Prof. Rhadamés Carmona _________________ __________________________ __________________ ________________ ________________ __________________ _________________ _________________ __________________ ________________ ________________ _____________ ____

Fundamentos Fundamentos para el cálculo de complejidad Prof. Rhadamés Carmona Ultima revisión: 08 / 01 / 2014 Los criterios para evaluar un programa son diversos: eficiencia, portabilidad, eficacia, robustez, etc. El análisis de complejidad está relacionado con la eficiencia del programa. La eficiencia mide el uso de los recursos del computador por un algoritmo. Por su parte, el análisis de complejidad mide el tiempo de cálculo para ejecutar las operaciones (complejidad en tiempo) y el espacio de memoria para contener y manipular el programa más los datos (complejidad en espacio). Así, el objetivo del análisis de complejidad es cuantificar las medidas físicas: "tiempo de ejecución y espacio de memoria" y comparar distintos algoritmos que resuelven el mismo problema. Los criterios que se van a emplear para evaluar la complejidad algorítmica no proporcionan medidas absolutas sino medidas relativas al tamaño del problema.

1. Complejidad en memoria Para medir la complejidad en memoria de un algoritmo, se debería considerar el espacio en memoria máximo requerido para su ejecución. Sin embargo, resulta casi imposible conocer el tamaño del programa en memoria (pues depende del lenguaje y arquitectura del computador); así pues nos limitamos a cuantificar el espacio en memoria requerido para almacenar los datos. Llamaremos Cm(T) al costo asociado al espacio para una variable u objeto de tipo T. Recordemos que los tipos de datos no ocupan espacio, sino las variables u objetos de un tipo. La unidad para medir la complejidad en memoria es la palabra de memoria (típicamente una palabra es de 32 bits o 64 bits). A continuación determinaremos los costos de distintos tipos de datos: a) Si T es un tipo elemental, entonces cualquier variable del tipo T tiene como costo una palabra. Así, Cm(T)=1. b) Un string de tamaño n ocupa Cm(string Cm(string)=n/4 )=n/4 palabras de memoria. Para este caso, asumimos que un caracter en un string ocupa 1 byte y que la unidad de palabra es de 4 bytes. c) Para un arreglo ar reglo unidimensional, usaremos la siguiente definición genérica: Type Array Arr Array Arr [ Li..Ls ] of Tbase Tbase Entonces Cm(Arr) = (Ls-Li+1)*Cm(Tbase). Para un arreglo bidimensional tenemos Type Array AB Array AB [Li1..Ls1, Li2..Ls2] of Tbase Tbase

Algoritmos y Estructuras de Datos, Universidad Central de Venezuela, Escuela de Computación. Prof. Rhadamés Carmona __________________________________________________________________________________________________________

Entonces Cm(AB)=(Ls1-Li1+1)*(Ls2-Li2+1)*Cm(Tbase) d) Para un registro fijo usaremos la siguiente definición genérica: Type Registro Reg T1 C1; T2 C2; ... Tn Cn; FinRegistro n

Entonces Cm(Reg) =

 Cm(Ti) i 1

Para un registro variante se suma la cantidad de memoria de la parte fija y discriminante, con el máximo en cantidad de memoria de la parte variable. e) Para un registro variante Type Registro Reg T1 C1; T2 C2; ...; Tk Ck; In case of TipoDisc Discri: : ; : ; ... : EndCase EndRecord k

Cm(Reg) = Cm(TipoDisc) +

 Cm(Ti)  Max{Cm( Datos ),..., Cm( Datos )} 1

n

i 1

f) Un apuntador ocupa también una palabra. g) El costo de una constante es igual al costo en memoria de variables de su tipo asociado. h) La definición de tipos no tiene costo alguno (no transcienden en el tiempo ni en el espacio). Sin embargo, se usa la notación Cm(Tipo) para la cantidad de memoria requerida por variables, objetos o constantes de dicho tipo.

2. Complejidad en tiempo Hay dos estudios posibles sobre el tiempo: uno que proporciona una medida Teórica (a priori), que consiste en obtener una función que acote (por arriba o por abajo) el tiempo de ejecución del algoritmo para unos valores de entrada dados. Otro que ofrece una medida real (a posteriori), que consiste en medir el tiempo de ejecución del algoritmo para unos valores de entrada dados y en un


computador concreto. Aún cuando ambas medidas son importantes, para nuestro caso consideraremos únicamente la medida teórica, puesto que es independiente del computador donde se ejecutará, y estará expresada en número de operaciones, y no en ninguna medida de tiempo. Este conjunto de pasos u operaciones está relacionado con el tamaño de los datos. Para cada problema se determina una medida n de su tamaño (por número de datos) y se busca hallar el número de operaciones T(n) que está en función de dicho n. El tamaño que indica n depende de la naturaleza del problema. Así, para un vector se suele utilizar como n su longitud; para una matriz, el número de elementos que la componen; para un grafo, el número de nodos o el número de arcos; en un archivo, el número de registros, etc. Se denota como T(n) el tiempo de ejecución de un programa sobre entradas de datos de tamaño n; intuitivamente T(n) es el número de instrucciones ejecutadas en un computador ideal, y es denominado también función de complejidad en tiempo para el algoritmo. Para el orden de complejidad del algoritmo, es usada la notación conocida como "big-oh" y es de la forma  (f(n)). Definición: De manera general, la complejidad T(n) de un algoritmo es de (f(n)) sii c+ y n0 tal que nn0 se cumpla T(n)c.f(n), donde T,f: +-{0}. En la definición anterior,  denota una relación de dominancia de funciones, en donde la función T está acotada superiormente por un múltiplo de la función f (T es dominada por c.f(n)). Así la expresión T(n)=(f) refleja que el orden de crecimiento asintótico de la función T es inferior o igual al de la función f . Ejemplo: T(n)=log2(n+1). Tomemos f(n)=log2(n). Aunque T(0) está definida, podemos restringir su dominio a T(n) con n>0. Así, que T,f: +-{0}, y además c+ (c=2) y n0 (n0=2) tal que nn0 se cumpla T(n)c.f(n). Así, log2(n+1)=log2(n) Ejemplo: p+1 p p+1 p Demostrar n (n ). Por reducción al absurdo, tomemos n =(n ). Entonces p+1 p p p c+ y n0 tal que nn0 se cumpla n c.n  n.n c.n  cn (contradicción, c debe ser constante). Se puede demostrar que  es una relación de preorden, porque es reflexiva y transitiva (no es simétrica). Así, Es reflexiva: f=(f) Es transitiva: f=(g)  g=(h)  f=(h).


Además,  satisface varias proposiciones; entre ellas ci taremos: Proposición 1: Si c+, y f: +-{0}, entonces, c.f(n)=(f(n)) Proposición 2: Si c+, y f: +-{0}, entonces de equivalente, y no el símbolo igual.

(c.f)(f).

Note el símbolo

Proposición 3: Si t1=(g1)  t2=(g2) entonces t1+t2=(g1+g2) Proposición 4: Si t1=(g1)  t2=(g2) entonces t1.t2=(g1.g2) Proposición 5: Si t1=(g)  t2=(g) entonces t1+t2=(g) Pruebas: (Prop.1) c+, y f: +-{0}

 n>0:

c.f(n)  c.f(n)  c.f=(f)

(Prop. 2) c.f.  1.c.f. Por tanto, c.f = O(c.f). Igualmente, c.f  c.f, por tanto c.f = O(f). Así, O(c.f) es equivalente a O(f). (Prop. 3) t1=(g1)  ft=(g2)  Por Def. 1, c,d+ y n1,n2 tal que nn1: t1c.g1 y

nn2:

t2d.g2 

t1(n)  c.g1(n) + t2(n)  d.g2(n) -----------------t1(n)+t2(n)  c.g1(n) + d.g2(n) Definamos la constante k como k = c+d. Es claro que t1(n)+t2(n)  c.g1(n) + d.g2(n) Por lo tanto, cumpla:

k+

t1(n)+t2(n)  k(g1(n)

+ g2(n))

(k=d+c) y n0 (n0=Max{n1,n2}) tal que

t1(n)+t2(n)  k.(g1(n) + g2(n))

nn0

se

 t1+t2=(g1+g2)

(Prop. 4) t1=(g1)  t2=(g2)  t1.t2=(g1.g2) Por Def. 1 c,d+ y n1,n2 tal que nn1: t1c.g1 y nn2: t2d.g2  k+ (k=d.c) y n0 (n0=Max{n 1,n2}) tal que nn0 se cumpla: t1(n).t2(n)  (d.c).(g1(n)+g2(n))  t1.t2=(g1.g2) (Prop. 5) t1=(g)  t2=(g). Por Prop.3 tenemos: t1+t2=(g+g)(2.g), y por la Prop. 2, (2.g)(g). Por lo tanto, t1+t2=(g) {Fin de pruebas}


Generalmente nos interesa la tasa de crecimiento f(n) del tiempo requerido para resolver instancias más grandes del problema, basándonos en el concepto de dominancia de funciones. La tasa de crecimiento obtenida para hallar el orden de complejidad en tiempo de un algoritmo, permite entre otras cosas: 





Determinar el comportamiento del algoritmo en función del tamaño del problema, y reflejar cuan grande puede ser el mismo. Determinar cuanto tiempo de cómputo aumenta al incrementar el tamaño del problema en una unidad (f(n+1)-f(n)). Facilita la comparación de algoritmos y permite determinar entre varios algoritmos, cual será el más eficiente en teoría (el que tiene menor tasa de crecimiento).

Las tasas de crecimiento suelen ser logarítmicas, polinomiales, y exponenciales. A continuación tenemos una comparación entre las tasas de crecimiento más comunes: 1 < log2n n  n.log2n n2 p3(n)  ... pk(n)  … < 2n  en  3n ...  nn  ... Donde pi(n) es un polinomio de grado i. Complejidad en el peor caso, caso promedio y mejor caso En muchos casos, la complejidad de tiempo de un algoritmo es igual para todas las instancias de tamaño n del problema. Como veremos posteriormente, este es el caso del algoritmo de ordenamiento conocido como Selección Directa. En otros casos, la complejidad de un algoritmo de tamaño n es distinta dependiendo de las instancias de tamaño n del problema que resuelve. Esto nos lleva a estudiar la complejidad en el pero caso, mejor caso, y caso promedio. Para un tamaño dado (n), la complejidad del algoritmo en el peor caso resulta de tomar el máximo tiempo (complejidad máxima) en que se ejecuta el algoritmo, entre todas las instancias del problema (que resuelve el algoritmo) de tamaño n; la complejidad en el caso promedio es la esperanza matemática del tiempo de ejecución del algoritmo para entradas de tamaño n, y la complejidad mejor caso es el menor tiempo en que se ejecuta el algoritmo para entradas de tamaño n. Por defecto se toma la complejidad del peor caso como medida de complejidad T(n) del algoritmo. Antes de presentar los principios básicos para calcular el tiempo de ejecución de un programa, se plantearán las reglas de suma y producto. Regla de la suma


Esta regla se deriva de la prop. 3. y la prop. 5. Sean T1(n) y T2(n) las funciones de complejidad para ejecutar dos instrucciones P 1 y P2 respectivamente (dos instrucciones de un programa), con T1(n)=(f(n)) y T2(n)=(g(n)). La complejidad en tiempo de la secuencia de instrucciones P 1;P2 es T1(n)+T2(n)=O(Max{f(n),g(n)}). Note que T1,T2: +-{0}, porque el tamaño de los problemas es entero positivo, y el tiempo Ti(n) siempre es real positivo. La demostración de esta regla es sencilla. Caso 1: Si f>g, entonces T1(n)c1.f(n) y T2(n)c2.f(n)      

T1(n) + T2(n)  c1.f(n) + c2.f(n) T1(n) + T2(n)  max(c1,c2) * (f(n) + f(n)) T1(n) + T2(n)  max(c1,c2) * 2 * f(n) T1(n) + T2(n)  2*max(c1,c2) * f(n), tomando c=2*max(c1,c2) T1(n) + T2(n)  c*f(n) T1(n) + T2(n) = O(f(n))

Caso 2: si f <= g entonces T1(n)c1.g(n) y T2(n)c2.g(n) 

T1(n) + T2(n)  c1.g(n) + c2.g(n)



…



T1(n) + T2(n) = O(g(n))

Regla del producto La regla de producto se deriva de la Prop. 4.: T1(n)=(f(n))  T2(n)=(g(n)) . T1(n).T2(n)=(f(n).g(n)) Sean c,d constantes tan que c,d +-{0}. De las reglas del producto, suma y las proposiciones, se deriva: 1.T(n)=c  T(n)=(1) 2.T(n)=c+f(n) T(n)=(f(n)) 3.T1(n)=c.f(n)  T1(n)=(f(n)) 4.T1(n)=c.f(n)+d  T1(n)=(f(n)) 5.T1(n)=(nk)  T2(n)=(nk+1)  T1(n)+T2(n)=(nk+1) 6.T(n)=c.nd  T(n)=(nd) 7.T(n) = Pk(n)  T(n)=( nk). (Pk(n) es un polinomio completo de grado k, con k=constante positiva). La razón es que cada término de este polinomio se puede acotar por el término dominante que es n k, y como hay k+1 términos, tendremos que Pk(n)  (k+1)*nk, lo cual es O(nk). La regla de la suma no se


puede aplicar n veces, ni ningún factor que dependa de n, puesto que estamos eliminando un término multiplicativo que depende del tamaño del problema, y que no es constante. 8.T1(n)=Ln(n)  T2(n)=nk  k1  T1(n)+T2(n)=(nk) 9.T1(n)=r n  T2(n)=Pk(n)  r 1  T1(n)+T2(n)=(r n) 10.- Demuestre que O( log na ) constantes.



O( log bn ), para cualesquiera a,b>1 y

Análisis de complejidad en tiempo de las instrucciones de un lenguaje A continuación se presentan algunas reglas para evaluar la complejidad en tiempo de los programas, tomando como base, el análisis para instrucciones en un pseudo-lenguaje. Regla 1: La función de complejidad en tiempo de una instrucción de asignación simple es una constante (que depende de la arquitectura donde se ejecutará el algoritmo), independientemente del tamaño de la entrada de datos, y es de orden (1). No todas las asignaciones son (1). Por ejemplo, una asignación como f factorial(n) involucra un algoritmo de n pasos para hallar el factorial de n, lo cual no puede ser (1). De aquí que nos referimos a sólo aquellas asignaciones que no involucran llamadas a funciones o procedimientos (que estudiaremos posteriormente). Ejemplos: b = 100; a = a+1; a = (b div 5) mod 7 – 3; Regla 2: La complejidad en tiempo de una salida o entrada simple (Read y Write) es T(n)=c (constante), por lo tanto es de orden (1) Regla 3: De la regla de la suma se deriva que la complejidad en tiempo de una secuencia de k (k es una constante) instrucciones cualesquiera P 1,P2, ..., Pk, siendo Ti(n)=(f i(n)) la complejidad de Pi, entonces la complejidad del bloque de instrucciones viene dada por k

 Ti( n)   (Max{ f ( n), f 1

2 ( n ),..., fk

( n)})

i 1

Ejemplo: Las tres instrucciones {b  100; a  a+1; a  (b div 5) mod 7 - 3} son de complejidad T1(n)=c1, T2(n)=c2, T3(n)=c3 respectivamente con c1c2c3 (porque las asignación de una constante puede ser más rápido que la de una suma, y esta a la vez, menos costosa que residuos y divisiones). Así, la función de complejidad de las tres instrucciones en conjunto es T(n)=T1(n)+T2(n)+T3(n)= c1+c2+c3 = O(1).


Nótese que no es relevante cual instrucción se tarda más y cual menos, porque al final T(n) es una constante y por ende de orden (1). Por esto, la complejidad de cada instrucción simple la tomaremos como la misma constante "c" para simplificar las cuentas. Regla 4: La complejidad en tiempo de una instrucción selectiva condicional simple de la forma: If Then EndIf está dado por la complejidad T1(n) de sumado a la complejidad T2(n) de (porque en el peor caso se ejecutan ambas). Por regla de la suma, si T1(n)=(f(n)) y T2(n)=(g(n)), entonces el tiempo requerido para ejecutar el condicional simple es la suma T1(n)+T2(n), lo cual es (Max{f(n),g(n)}).

Análogamente, para una instrucción selectiva de la forma: // es de complejidad T 1(n)=(f(n)) If Then // bloque de complejidad T2(n)=(g(n)) Else // bloque de complejidad T3(n)=(h(n)) EndIf su complejidad está dado por: T1(n)+Max{T2(n)+T3(n)}, lo cual, por regla de la suma es de orden ( Max{ f(n), Max{g(n),h(n)} } ) o sencillamente ( Max { f(n), g(n), h(n) } ) Ejemplo: Para una construcción de la forma: If Then Else If Then EndIf EndIf Donde: tiene como tiempo T1(n)=O(f 1(n)) tiene como tiempo T2(n)=( f 2(n)) tiene como tiempo T3(n)=O(f 3(n)) tiene como tiempo T 4(n)=( f 4(n))


La complejidad viene dada por T(n) = Max{T1(n) + T2(n), T1(n) + T3(n) + T4(n)} = (Max { Max{f 1(n),f 2(n)}, Max{f 1(n),f 3(n),f 4(n)} } )  (Max { f 1(n),f 2(n),f 3(n),f 4(n) } ) Regla 5: La complejidad en tiempo de un ciclo iterativo de tipo While o Repeat es la suma sobre todas las iteraciones de:  

la complejidad en tiempo para ejecutar el cuerpo de la iteración, y la complejidad en tiempo para evaluar la condición de terminación del ciclo.

While Do EndWhile

// se evalúa k veces // se ejecuta k-1 veces

La fórmula general supone que en cada iteración, se tiene un tiempo de evaluación de la condición Tcondi(n) y un tiempo de ejecución de las Ti(n) que puede variar iteración por iteración. Lo más importante es que la condición se evalúa una vez más que las instrucciones. T (n) 

k



Tcond i (n) 

i 1

k 1

 T (n) i

i 1

Generalmente, Tcondi(n) es una comparación sencilla, por lo que Tcond i(n)=c., pero en ocasiones puede haber invocaciones a funciones complejas cuyo tiempo no es una constante. El tiempo requerido para ejecutar las puede depender de la iteración. El valor de k no tiene que ser una constante. En caso que dependa de n, entonces tendrá un impacto sobre el tiempo total, y efectivamente sobre el orden de complejidad.

Repeat Until

// se ejecuta k veces // se evalúa la misma cantidad de veces (k)

En este caso: k

T (n)   Tcond i (n) T i (n) i 1

For = To Do // se ejecuta Final-Inicio+1 veces EndFor


El for es equivalente a: Variable = Inicio While (Variable  Final) Do Variable = Variable+1 EndWhile

// se ejecuta 1 vez // se evalúa Final-Inicio+2 veces // se ejecuta Final-Inicio+1 veces // se ejecuta Final-Inicio+1 veces

Tanto la condición, el incremento y la inicialización tienen un tiempo equivalente a c. El tiempo es

 final  T (n)  c  ( final  inicio  2) * c    T i (n)   ( final  inicio  1) * c  i inicio   final  T (n)  2 * ( final  inicio  2) * c    T i (n)   i inicio  EJERCICIO: Hallar tiempo y orden de complejidad para los algoritmos de búsqueda lineal y búsqueda binaria. Regla 6: Si se tiene un programa con procedimientos (no recursivos), se calcula su complejidad en tiempo usando las reglas anteriores. Si existen procedimientos recursivos, la complejidad es obtenida por una ecuación de recurrencia. En ocasiones, la complejidad de algoritmos no recursivos (como una implementación de búsqueda binaria) puede hallarse por ecuaciones de recurrencia. Por lo general, las ecuaciones de recurrencia surgen cuando resolvemos un problema mediante la descomposición de éste, en varios subproblemas idénticos de tamaño menor. Ecuaciones de recurrencia por partición: Este tipo de ecuaciones de recurrencia surgen cuando un problema de tamaño n es resuelto mediante la solución de varios sub-problemas de tamaño n/b. Problemas tipo divide y conquista caen dentro de este grupo de problemas. Antes de introducir la fórmula general de una ecuación de recurrencia por partición, estudiaremos la complejidad en tiempo del algoritmo de ordenamiento por mezcla (merge-sort). El algoritmo de merge-sort se basa en que el problema de ordenar una lista de n elementos, se reduce a ordenar dos sublistas de tamaño n/2 cada una, y luego de ordenarlas, mezclarlas para obtener la solución. Este proceso se repite recursivamente, hasta que el tamaño de la lista sea uno. Por simplicidad asumimos que n es una potencia de dos (n=2 k). El algoritmo puede expresarse a muy alto nivel como sigue:


Function MergeSort(Integer n; Lista L) -> Lista Lista L1, L2; If n==1 Then Return L; Else L1 = Lista de los primeros n/2 elementos de L L2 = Lista de los últimos n/2 elementos de L Return (Mezcla(MergeSort(n/2,L1),MergeSort(n/2,L2))); EndIf EndFunction La ejecución del algoritmo puede verse gráficamente en la siguiente figura para una lista de 4 elementos: (5,2,4,6). 2

4

5

6

mezcla 2

5

4

mezcl a 5

6

mezcla 2

4

6

Niveles de recursión del algoritmo de MergeSort El las hojas del árbol de ejecución, las listas son de tamaño uno (n=1), y la complejidad en este caso es la complejidad de la instrucción de retorno la cual es un constante que llamaremos c1. En cada activación de la función con n>1, el problema es dividido en dos subproblemas con un costo adicional para construir las listas L1 y L2 (c3.n/2 cada una) y una mezcla de dos listas de tamaño n/2 (costo c4.n). T(1) = c1 T(n) = 2.T(n/2) + c3*n/2+ c3*n/2+c4.n, si n>1. Si denominamos c2=c3+c4, tenemos que la complejidad del algoritmo tiene la siguiente ecuación de recurrencia: T(1) = c1 T(n) = 2.T(n/2) + c2.n, si n>1. Bajo la hipótesis de que n=2k, podemos hallar la fórmula no recurrente de T(n). Probamos para n=1,2,4,8; luego generalizaremos para cualquier n=2k. T(1) T(2) T(4) T(8)

= c1 = 2.T(1)+2.c2 = 2.c1+2.c2 = 2.c1+2.Log2(2).c2 = 2.T(2)+2.c2 = 2.(2.c1+2.Log2(2).c2)+2.c2 = 4.c1+4.Log2(4).c2 = 2.T(4)+2.c2 = 2.(4.c1+4.Log2(4).c2)+2.c2 = 8.c1+8.Log2(8).c2


... T(n)

= 2.T(n/2)+2.c2 = n.c1+n.Log2(n).c2

Haciendo inducción sobre n=2k, tenemos: Hipótesis: Tesis:

T(n)=n.c1+n.Log2(n).c2 y T(n)=2.T(n/2)+c2.n T(2.n)=2.n.c1+2.n.Log2(2.n).c2

Prueba:

T(2.n) = 2.T(n)+2.c2.n = 2.(n.c1+n.Log2(n).c2)+2.c2.n = 2.n.c1+2.n.c2.(Log2(n)+1) = 2.n.c1+2.n.c2.(Log2(n)+Log2(2)) = 2.n.c1+2.n.Log2(2.n).c2

Claramente vemos que T(n) = O(n*log2(n))

Así como el algoritmo de MergeSort, muchos algoritmos suelen reducir problemas de tamaño n, a varios subproblemas de tamaño n/b (b>0). A estos algoritmos se les denomina comúnmente algoritmos divide-conquista, y el orden de complejidad en tiempo de éstos tiene como fórmula general de recurrencia: T(1) = 1 { se toma T(1)=1 por conveniencia } T(n) = a.T(n/b)+f(n), si n>1 en donde a es el número de subproblemas, n/b el tamaño de cada subproblema, y f(n) la función que denota el costo de dividir y/o combinar los subproblemas. Asumiendo que n=bk, tenemos: T(1) = 1 T(b) = a.T(1)+f(b) = a+1.f(b) T(b2) = a.T(b)+f(b2) = a.(a+1.f(b))+f(b2) = a2+a.f(b)+1.f(b2) T(b3)

= a.T(b2)+f(b3) = a.(a2+a.f(b)+1.f(b2)) +f(b3) = a3+a2.f(b)+a.f(b2)+f(b3)

... T(bk) = a.T(bk-1)+f(bk) = a k 

k 1

 a . f (b i

k i

)a  k

i 0

k 1

b k

 a . f ( b i

i 0

i

)

Considerando que n=bk, tenemos: T (n)  a

log bn



log bn 1

 a . f ( i

n

i 0

bi

)

Sabiendo que por propiedades tenemos finalmente que: T (n)  n

log ba



log bn 1

 a . f ( i 0

i

n

bi

)

a

logbn

b

logba

logn b

 b log

n a b . logb

n b

a b

a b

 (b log ) log  n log ,


Como es de notarse, esta función no es fácil de evaluar, amenos que se posea más información acerca de la función f(n). Para el caso de que f sea un función multiplicativa (f(x.y)=f(x).f(y)), se cumple que f(bk-i)=f(b)k-i. Por lo tanto, si f es multiplicativa T(n) nos queda: T (n)  a  k

k 1

 a . f (b) i

k  i

i 0

k

 r

Además, como

 a  f (b) . ( f a(b ) )i k

(4.1)

i 0

k 1

i

k 1

k



i 0

k T (n)  a  f (b)

1

r

r  1

, nos queda que:

( a ) k  1 k f ( b ) (

) 1

a f ( b )

 a k 

a k  f (b) k ( f (ab ) )  1

n

log ba



n

f ( b ) b

log ba

 nlog ( f a(b ) )  1

Para conocer el orden de T(n) estudiaremos los siguientes casos:

Caso a: a0, y para valores grandes de n tenemos que: n

logba

 nlog c

f ( b ) b



n

f ( b )

logb

 nlog

a b

c



n

f ( b )

logb

c

a b

 T (n)  nlog  n

f ( b ) log b

c

 nlog

f ( b ) b

n

f ( b ) log b

c



n

f ( b ) log b

c

(1  1c )  (n

f ( b )

logb

Caso b: a=f(b). Sustituimos a por f(b) en (4.1) y obtenemos: T (n)  a k  k .a k  a k (1  k )  n

log ba

(1  logbn )  (n

log ba

.logbn )

Caso c: a>f(b). Si a>f(b), entonces a/f(b)-1 = c > 0, y para valores grandes de n tenemos que: n

logba

 nlog

f ( b ) b

c



log ba

n

c

a b

a b

 T (n)  1c nlog  (nlog )



Max{ a , f ( b )}

Los casos a y c pueden resumirse en  n b dentro de este caso c considerando a=b=2. log

. Nótese que Merge-Sort cae

Casos particulares que se pueden encontrar en los libros e internet En muchos de los casos, el costo de dividir o combinar soluciones es n. Es decir, F(n) = n. Esto genera una simplificación clara, en donde se suele plantear: T(1) = 1 T(n) = a.T(n/b)+n, si n>1 Esta ecuación de recurrencia tiene como resultado:

)


si a  b  O ( n)  T (n)   O(n log b n) si a  b O(n log ) si a  b  a b

El algoritmo de merge-sort cae en el caso a=b=2, es decir, O(nlog 2(n)), debido a que se reduce un problema de tamaño n a dos problemas de tamaño n/2 con un costo de combinación (mezcla y partición) igual a n. En otros casos, el costo de combinar las soluciones es una constante. En estos casos se suele plantear la recurrencia T(1) = 1 T(n) = a.T(n/b)+1, si n>1 Lo cual resulta si a  1

 O(1)  T (n)   O(log b n) O(n log ) 

si a  1

a b

si a  1

El algoritmo de búsqueda binaria cae en el caso a=1 y b=2, pues se reduce un problema de tamaño n a un problema de tamaño n/2 con un costo de combinación igual a una constante. Demostración: T(1) = 1 T(b) = a.T(1)+1 = a+1 T(b2) = a.T(b)+1 = a(a+1)+1 = a2+a+1 T(b3) = a.T(b2)+1 = a(a2+a+1)+1 = a3+a2+a+1 …

k

k

k-1

T(b ) = a.T(b )+1 =

a

i

i 0

Para expresarlo en función de n, igualamos n=bk k

T(b ) =

log bn

k

a

i

 T(n)=

i 0

a

 k

= logbn. Sustituyendo:

i

i 0

Analicemos ahora los tres casos: log bn

a=1: en este caso T(n)=

1

i

 T(n)=

log bn

i 0

log bn

a>1: T(n)=

a i 0

resultado:

i

. Esto es la serie geométrica con razón a, lo cual tiene como


a

T(n) =

log bn 1

a

1

1

n

=

a.a

log b

1

a 1

a

=

a.n

log b

1

a 1

= O( n

log ba

)

n

n

log b

a<1: T(n)=

a

i

a.a

. De manera similar al caso anterior, esto es n

claro que si a<1, entonces a

<1 también. Por lo tanto

a.a

1

a 1

i 0

log bn

log b

log b

1

a 1

. Es

< 2 = O(1).

En casos menos comunes, el costo de combinar las soluciones puede ser nk, con k un entero mayor a 0. En este caso se puede plantear T(1) = 1 T(n) = a.T(n/b)+nk, si n>1 Lo cual resulta

 O(n k ) si a  b k  T (n)  O(n k log b n) si a  b k O(n log ) si a  b k  a b

Otras fórmulas maestras para algoritmos recursivos, pero no por partición Estos se aplican por ejemplo para factorial, fibonacci, etc. Ejemplo 1: T(n) = 1 si nn0 T(n) = a*T(n-c)+1 si n>n0 Demuestre que

 O(1)  T (n)   O(n) O(a n / c ) 

si a  1 si a  1 si a  1

Ejemplo 2: T(n) = 1 si nn0 T(n) = a*T(n-c)+n si n>n0 Demuestre que


 O ( n)  T (n)  O(n 2 ) O(a n / c ) 

si a  1 si a  1 si a  1

Ejercicios: - Hallar el orden de complejidad en tiempo de la función potencia xy, con el algoritmo divide y conquista. Demuestre que es O(Log2n) - Hallar la complejidad en tiempo de búsqueda binaria. Demuestre que es O(log2n) - Hallar la complejidad en tiempo de Quick Sort y Selección Directa. Demuestre que en peor de los casos QuickSort es O(n 2), aunque en el caso promedio es O(nlog2n). Demuestre que Selección Directa es O(n 2). - Demuestre que Fibonacci en su implementación recursiva es de orden exponencial, mediante la siguiente recurrencia en el cálculo del tiempo T(n) = 1, si n<2 T(n) = T(n-2)+T(n-1)+1, si n>=2 -

Demuestre que factorial es lineal O(n) Escriba el algoritmo de Torres de Hanoi, deduzca su complejidad en tiempo T(n) y su orden de complejidad.

complejidad en tiempo y espacio

Recommend Documents