6 Introducci´on al An´alisis de Algoritmosnbaloian/cc3001-02/Auxiliares/auxiliar2.pdf · 6...

6 INTRODUCCION AL ANALISIS DE ALGORITMOS

Quick_Sort(A,izq,k-1);Quick_Sort(A,k+1,der);

fin_si

En este caso, el algoritmo depende de la eleccion del pivote. Es recomend-able determinar el pivote aleatoriamente para minimizar la probabilidad de laocurrencia de malos casos. Pues Quick Sort tiene costo cuadratico en el peorcaso. Sin embargo, en promedio, su desempeno practico es mejor que MergeSort. El costo promedio de Quick Sort tambien es O(nlogn).

6 Introduccion al Analisis de Algoritmos

Los algoritmos realizan un numero de operaciones de acuerdo a la cantidadde datos (n) que procesan. El analisis de algoritmos consiste en determinarteoricamente el orden de la cantidad de estas operaciones. Cuando el numerode operaciones es fijo o constante y no depende de n se dice que el algoritmo esde orden 1 y lo representaremos como O(1). En este sentido, un numero fijo deasignaciones, multiplicaciones o comparaciones sera de orden 1 (O(1)).

En general definimos el numero de operaciones como T (n), cumpliendo:

• T (n) ! R, T (n) " 0.

• n ! N, n " 0.

y T (n) = O(f(n)) si:T (n) # cf(n) (1)

para c ! R y c > 0.Por lo general, f(n) tiene un solo termino (Ej, 1, n, n2, 2n) y es la menor

funcion que cumple Eq.1. Entonces, si un algoritmo esta asociado a un T (n)y T (n) = O(f(n)) diremos que el algoritmo es de orden f(n). Ası podrıamostener los siguiente tipos de algoritmos:

• Algoritmo de tiempo constante, si T (n) = O(1).

• Algoritmo logarıtmico, si T (n) = O(logn).

• Algoritmo lineal, si T (n) = O(n).

• Algoritmo cuadratico, si T (n) = O(n2).

• Algoritmo exponencial, si T (n) = O(an), para una constante a.

Ası, mientras menor sea el orden de los algoritmos, mas eficientes son estos.Muchos algoritmos tienen un T (n) representado por un polinomio de la

forma:T (n) = a0 + a1n + a2n

2 + · · · + apnp,

en este caso el orden del algoritmo esta gobernado por el orden del polinomio.Por lo tanto, T (n) = O(np). Por ejemplo, si un algoritmo tiene asociado unT (n) = 1

2n2 +n$3, el algoritmo tiene orden cuadratico, es decir T (n) = O(n2).

Regla del Maximo: La regla del maximo dice que si T (n) = t1(n) + t2(n),siendo t1 = O(f1(n)) y t2(n) = O(f2(n)), entonces T (n) = O(max(f1(n), f2(n))).

14 Jose M. Saavedra


6.1 Recurrencias

Los algoritmos recursivos expresan su T (n) tambien en forma recursiva, comopor ejemplo el numero de operaciones del algoritmo Merge Sort esta dado por:

T (n) =

!1 si n # 1

2T"n

2

#+ n si n > 1

Calcular el orden de un T (.) recursivo no es facil, por lo que debemos transformarT (.) en una funcıon equivalente pero no recursiva. Este proceso se denominaresolucion de recurrencia.

Algunas estrategias para resolver la recurrencia se muestran a continuacion.

6.1.1 Recurrencias Telescopicas

Las recurrencias telescopicas tienen la siguiente forma:

Xn+1 = an + Xn

resolviendo Xn hasta el caso base X0 tenemos:

Xn+1 = X0 + a0 + a1 + · · · + an

Xn+1 = X0 +n$

i=0

ai

Ejercicios: Resolver las siguientes recurrencias:

1. T (n) = 2n + T (n$ 1), donde T (0) = 1.

2. T (n) = T (n$ 1) + log2(n), donde T (0) = 1.

6.1.2 Cambios de variable

En algunos casos, la forma telescopica no se observa directamente. Utilizandocambios de variable podemos hacer notoria la forma anterior y facilitar la reso-lucion de la recurrencia.

Por ejemplo, sea T (n) = 2T (n2 )+n con el caso base T (n) = 1 cuando n # 1.

Para solucionar este problema supondremos que n = 2p, entonces tenemos:

T (2p) = 2T (2p!1) + 2p

La forma telescopicas no es notoria, pero veamos lo que ocurre si hacemos queT (2p) = y(p), tedremos:

y(p) = 2y(p$ 1) + 2p

y luego dividimos todo por 2p, haciendo que y(p)/(2p) = r(p) tendremos

r(p) = r(p$ 1) + 1

ahora sı tenemos la forma telescopica que al resolverla nos queda:

r(p) = r(0) +p!1$

i=0

1

r(p) = 1 + p

15 Jose M. Saavedra


Ahora obtenemos T (n) = y(p) = r(p)2p = 2p + p2p = O(nlogn),


1. T (n) = 2T (n$ 1) + 1, donde T (0) = 1.

6.1.3 Ecuacion caracterıstica

Sea la ecuacion de la forma:

akTn+(k) + ak!1Tn+(k!1) + · · · + a0Tn = 0

reemplazamos Tn = !n, y tenemos:

!n(ak!k + ak!1!k!1 + · · · + a0!

0) = 0

pero como !n no puede ser 0, entonces:

ak!k + ak!1!k!1 + · · · + a0!

0 = 0.

Ahora, tenemos k raıces: !1, . . . ,!k.

Solucion General: Tn = c1!n1 + c2!n

2 + · · · + ck!nk


1. T (n) = 5T (n$ 1)$ 4T (n$ 2), donde T (1) = 3, T (2) = 15.

2. T (n + 1) =%

T (n)T (n$ 1), donde T (0) = 1, T (1) = 2.

6.2 Casos de Estudio

En esta parte revisaremos algunos problemas interesantes con diferentes alterna-tivas de solucion usando estrategias como Divide & Conquista y ProgramacionDinamica.

6.2.1 Subsecuencia de Suma Maxima

Sea Q = a1, a2, . . . , an una secuencia de n enteros (posiblemente negativos),el objetivo es encontrar (i, j), 1 # i # j # n, representando una subsecuencia

contigua ai, . . . , aj en Q, tal quej$

k=i

ak sea la mayor para cualquier i, j. Visto

desde el punto de vista de optimizacion serıa:

argmax1"i"j"n

&j$

k=i

ak

'.

Si para todo a ! Q, a < 0 entonces la suma maxima es 0.

Ejemplo:

• S =-2, 11, -4, 13, -5 -2

16 Jose M. Saavedra


• SSM= 20

Algoritmo de Fuerza Bruta

• Aquı, simplemente calculamos la suma para toda posible subsecuencia.

• Nos quedamos con la que tenga la mayor suma.

Algorithm 1 Algoritmo de fuerza bruta para SSM.1: smax % 02: for i = 1 to n do3: for j = i to n do4: s % 05: for k = i to j do6: s % s + ak

7: if s > smax then8: smax % s9: i# % i

10: j# % j11: end if12: end for13: end for14: end for15: return [smax, i#, j#]

El algoritmo mostrado en Alg. 1 es un algoritmo ingenuo, muy ineficiente,

cuyo tiempo esta dado por: T =n$

i=1

n$

j=i

j$

k=i

1, dando un orden O(n3).

Algoritmo de Fuerza Bruta Mejorado

Podrıamos hacer algo mejor que lo anterior al notar que para un i fijo esta-mos recalculando sumas al variar j. Es decir, podemos evitar una ciclo iterativosi evitamos recalcular la suma desde i hasta j$1 para un nuevo valor de j. Ası,tendrıamos el siguiente algoritmo:

Ahora tenemos un algoritmo con T =n$

i=1

n$

j=i

1 de orden cuadratico O(n2).

Algoritmos Divide & ConquistaEs posible aun obtener una mayor eficiencia si dividimos el problema en

dos subproblemas, resolviendolos por separado, para finalmente obtener unasolucion mezclando ambas soluciones parciales (principio divide & conquista).

Entonces, dada la secuencia Q, la dividimos en mitades como se muestra en laFigura 1. Luego resolvemos por separado cada mitad. Llamemos m1 a la ssm dela izquierda y m2 a la correspondiente suma de la derecha. Ademas, supongamosque m1 corresponde a la subsecuencia que va dese p hasta q, mientras que m2corresponde a la subsecuencia que va desde r hasta s. Tenemos dos soluciones,la pregunta ahora es ¿como mezclar ambas?.

Para obtener el resultado final, tenemos que notar que al descomponer lasecuencia en dos partes dejamos de evaluar el comportamiento de las subse-cuencias que cruzan el centro. Por lo tanto, debemos encontrar la ssm que pasa

17 Jose M. Saavedra


Algorithm 2 Algoritmo de fuerza bruta para SSM mejorado1: smax % 02: for i = 1 to n do3: s % 04: for j = i to n do5: s % s + aj

6: if s > smax then7: smax % s8: i# % i9: j# % j

10: end if11: end for12: end for13: return [smax, i#, j#]

Figure 1: Esquema divide y conquista para el problema SSM.

por el centro y va hasta p por la izquierda y hasta s por la derecha. Llamemosx a esta ultima ssm. El resultado final es max(x, m1, m2). El Alg. 3 describeel algoritmo completo.

Ahora, tenemos un tiempo recursivo de T (n) = 2T (n/2) + O(n), que al re-solverlo nos da T (n) = nlog(n). Por lo tanto, tenemos un algoritmo de ordenO(nlogn), mucho mas eficiente que los dos previamente discutidos. Habra unalgoritmo mas eficiente?.

Algoritmo SSM Lineal

Podemos llegar a un orden lineal para resolver el problema de subsecuenciade suma maxima. Definamos primero la siguiente asercion:

La mejor subsecuencia no puede comenzar con un numero nega-tivo. En general, ninguna subsecuencia de suma negativa puede serprefijo de la subsecuencia optima.

El algoritmo se basa en dos invariantes para cada posicion j, t.q. 1 # j # n.

• Se conoce la mejor subsecuencia desde 1 hasta j.

• Se conoce la mejor subsecuencia que termina en j.

Por lo tanto, necesitamos dos variables, ssm y sp, que almacenen los val-ores antes descritos, respectivamente. Inicialmente, ambas variables son cero.Cuando la mejor subsecuencia que termina en j se hace negativa, reseteamos lasegunda variable, pues ninguna subsecuencia que termina en j puede ser parte

18 Jose M. Saavedra


Algorithm 3 SSM DCRequire: Q : a1, . . . , an; izq, der1: centro % izq+der

22: if izq = der then3: if aizq < 0 then4: return [0,$1,$1]5: else6: return [aizq, izq, der]7: end if8: else9: [m1, p, q] % SSM DC(Q, izq, centro)

10: [m2, r, s] % SSM DC(Q, centro + 1, der)11: sp % 0;12: maxizq % 0;13: xizq % $114: for i = centro down to p (p > 0) do15: sp % sp + ai

16: if sp > maxizq then17: maxizq % sp18: xizq % i19: end if20: end for21: sp % 022: maxder % 023: xder % $124: for i = centro + 1 to s do25: sp % sp + ai

26: if sp > maxder then27: maxder % sp28: xder % i29: end if30: end for31: ssm = max(m1, m2, maxizq + maxder)32: if m1 = ssm then33: return [m1, p, q]34: else35: if m2 = ssm then36: return [m2, r, s]37: else38: return [maxizq + maxder, xizq, xder]39: end if40: end if41: end if

de la subsecuencias buscada. El algoritmo en Alg. 4 describe la propuesta lineal.Es facil notar que el algoritmo mostrado en Alg. 4 tiene un tiempo de ejecucionde orden O(n).

19 Jose M. Saavedra


Algorithm 4 Algoritmo lineal para SSM1: ssm % 02: sp % 03: i0 % 04: for j = 1 to n do5: sp % sp + aj

6: if sp > ssm then7: ssm % sp8: i# % i0 + 19: j# % j

10: else if sp < 0 then11: sp % 012: i0 % j13: end if14: end for15: return [ssm, i#, j#]

6.2.2 Multiplicacion de Matrices

Dadas dos matrices cuadradas A, B de N & N (si A y B tienen diferentes di-mensiones se pueden rellenar con ceros siempre que ambas sean multiplicables)el problema es obtener C = A&B eficientemente.

Algoritmo tradicional

El algoritmo tradicional consiste en recorrer cada fila de A y cada columnade B, obtener el producto punto de la fila i en A y columna j en B, el resultadoes asignado a la posicion i, j en C. Esto toma tiempo O(N3), el algoritmo semuestra en Alg. 5.

Algorithm 5 Algoritmo tradicional para multiplicar matrices1: for i = 1 to N do2: for j = 1 to N do3: s % 04: for k = 1 to N do5: s % A[i][k]&B[k][j] + s6: end for7: C[i][j] % s8: end for9: end for

Algoritmo Divide & Conquista

Supongamos que dividimos las matrices en cuatro zonas, tal como se muestraen la Figura 2. En este caso tenemos 8 subproblemas a resolver cuyas solucionescomponen la solucion final de la siguiente manera:

• C11 = A11B11 + A12B21

• C12 = A11B12 + A12B22

20 Jose M. Saavedra


Figure 2: Esquema divide y conquista para la multimplicacion de matrices.

• C21 = A21B11 + A22B21

• C22 = A21B12 + A22B22

La composicion final toma tiempo O(N2). Sin embargo, este algoritmo tiene untiempo recursivo de T (N) = 8T (N/2) + O(N2) cuyo orden sigue siendo cubico,O(N3).

Algoritmo de Strassen

Strassen propuso en 1969 una forma de calcular el producto de matrices basadaen la estrategia divide & conquista, como se describio anteriormente, pero en laque solamente se necesitan resolver 7 subproblemas. La propuesta es la sigu-iente:

• M1 = (A12 $A22)(B21 + B22)

• M2 = (A11 + A22)(B11 + B22)

• M3 = (A11 $A21)(B11 + B12)

• M4 = (A11 + A12)B22

• M5 = A11(B12 $B22)

• M6 = A22(B21 $B11)

• M7 = (A21 + A22)B11

La composicion de la solucion final esta dada por:

• C11 = M1 + M2 $M4 + M6

• C12 = M4 + M5

• C21 = M6 + M7

• C22 = M2 $M3 + M5 $M7

Esta solucion tiene un tiempo recursivo de T (N) = 7T (N/2) + O(N2) cuyoorden es O(7log2N ) ' O(N2.81). La complejidad asintotica de este algoritmo esligeramente menor que la del algoritmo tradicional para multiplicar matrices.Sin embargo, en la practica el algoritmo de Strassen funciona mucho mejor.

21 Jose M. Saavedra


6.2.3 Subsecuencia Comun mas larga

En los dos casos anteriores hemos visto como aplicar la estrategia Divide &Conquista en la solucion de problemas. Ahora veremos como aplicar la Progra-macion Dinamica en el problema de la Subsecuencia Comun mas larga (LCS).

LCS es uno de los problemas con muchas aplicaciones en Bioinformatica,como por ejemplo encontrar patrones similares en secuencias de ADN. En terminosgenerales, el objetivo de LCS es econtrar la subsecuencia (no necesariamentecontigua) comun mas larga entre dos secuencias (ej. strings).

Sea X, Z dos secuencias de largo m y n, respectivamente. Por simplicidadpensemos en secuencias de caracteres:

X = x1, x2, . . . , xm

Z = z1, z2, . . . , zn

diremos, en este problema, que Z es una subsecuencia de X, si existe unasecuencia i1, . . . , in, t.q. ij es una posicion en X, en donde se cumple:

• ij < ij+1 (j = 1 . . . n$ 1 y

• xij = zj (j = 1 . . . n.

Problema: Dados 2 strings X, Y encontrar la subsecuencia Z de mayorlongitud comun a X e Y .

Algoritmo de Fuerza Bruta

El algoritmo de fuerza bruta requiere calcular todas las subsecuecias de X yde Y , para luego buscar la comun de mayor longitud. Calcular todas las subse-cuencias de un string X es como calcular el conjunto potencia del conjunto desımbolos de X, en el que cada sımbolo es considerado diferente al resto. Ası, eltiempo requerido para este calculo es O(2|X|), lo que lo hace inaplicable.

Algoritmo Recursivo

Sea Xi el i-esimo prefijo del string X, es decir:

Xi = x1, x2, . . . xi

donde, 0 # i # m, siendo m = |X| y X = Xm. Ademas definimos, X0 =" (cadena vacıa). Ası, LCS(X,Y ) = LCS(Xm, Yn) y se sigue la siguientedefinicion recursiva:

LCS(Xi, Yj) =

()*

)+

LCS(Xi!1, Yj!1) ) xi si xi = yj

argmax(|LCS(Xi, Yj!1)|, |LCS(Xi!1, Yj)|) en otro caso.

(2)donde, ) indica concatenacion. Implementar la solucion recursiva es muy

caro, tambien de orden exponencial. Sin embargo, el uso de programaciondinamica nos permite implementar la solucion recursiva eficientemente.

Algoritmo basado en Programacion Dinamica

22 Jose M. Saavedra


Considerando la solucion recursiva anterior, definimos L como una matriz detamano (m + 1) & (n + 1), en donde L[i, j] = |LCS(Xi, Yj)|. Inicialmente,L[i, 0] = L[0, j] = 0 (i = 0, . . . ,m; j = 0. . . . , n. Luego, la matriz L es llenadade la siguiente manera:

L[i, j] =

()*

)+

L[i$ 1, j $ 1] + 1 si xi = yj

max(L[i, j $ 1], L[i$ 1, j]) en otro caso. (3)

Finalmente, |LCS(X, Y )| = L[m, n], pero no tenemos la secuencia en sı.Sin embargo, se puede recuperar el string correspondiene a LCS(X, Y ), si apartir L[m.n], retrocedemos por donde se encontro los maximos valores o por ladiagonal, recuperando lo sımbolos correspondientes. Para ello, necesitamos unmatriz adicional B de tamano (m + 1)& (n + 1), que almacene la direccion deretorno, como se muestra a continuacion.

B[i, j] =

(*

+

B[i, j] = D si xi = yi

B[i, j] = I si L[i, j $ 1] > L[i$ 1, j]B[i, j] = A si L[i, j $ 1] < L[i$ 1, j]

(4)

A: arriba, D: diagonal, I: izquierda. Un algoritmo simple para recuperarLCS(X, Y ), dados B, X e Y es el que se muestra en Alg. 6. En este caso, elalgoritmo se basa en llenar las matrices L y B, por lo que el tiempo de ejecuciones de orden O(m& n).

Algorithm 6 Recuperar LCSRequire: X, Y, B, i, j1: s % "2: if i! = 0ANDj! = 0 then3: if B[i, j] =$ A$ then4: s % Recuperar LCS(X, Y, B, i$ 1, j)5: else if B[i, j] =$ I $ then6: s % Recuperar LCS(X, Y, B, i, j $ 1)7: else8: s % Recuperar LCS(X, Y, B, i$ 1, j $ 1))X[i]9: end if

10: end if11: return s

En la Figura 3 se muestra un ejemplo de la soluciom de LCS usando progra-macion dinamica.

6.2.4 Distancia de Edicion entre Cadenas

Otro problema interesante es el de comparar cadenas usando una distancia quenos dice que tan diferentes son dos cadenas. Para eso existe un algoritmo famosoque se denomina Distancia de Edicion o Distancia de Levenshtein cuyo fun-cionamiento se describe a continuacion.

Sean X = x1, x2, . . . xm y Y = y1, y2, . . . , yn dos cadenas (strings) de largom y n respectivamente, la distancia de edicion entre X, Y se define como el

23 Jose M. Saavedra

7 ORDEN ESTATICO

Figure 3: En la derecha se muestra la matriz L, mientras que en la izquierdaaparece la matriz B. El texto recuperado se muestra de color verde.

mınimo numero de operaciones elementales que hay que realizar para convertiruna cadena en la otra.

Las operaciones elementales son de tres tipos: (1) Insercion, cuando se agregaun caracter a una de las cadenas, (2) Eliminacion, cuando se quita un caracterde una de las cadenas, y (3) Sustitucion, si un caracter se cambia por otro.

Ademas definimos Xi como la subcadena con los primeros i caracteres dela cadena X. Ası, Xi = x1, . . . xi. La distancia de edicion entre Xi e Yj ,DE(Xi, Yj) se define recursivamente como:

DE(Xi, Yj) =

())*

))+

DE(Xi!1, Yj!1) xi = yj

min(DE(Xi!1, Yi!1),DE(Xi!1, Yi),

DE(Xi, Yi!1)) + 1 xi *= yj

(5)

donde DE(X0, Yi) = i o DE(Xi, Y0) = i. Finalmente, DE(X,Y ) = DE(Xm, Yn).Solucionar este problema en forma recursiva resulta en un algoritmo inefi-

ciente. La forma de atacar este problema es usando Programacion Dinamica.En este sentido definimos una matriz D de (m+1)&(n+1) celdas, donde D[i, j]almacena la distancia de edicion calculada entre Xi e Yj .

• Inicializacion: D[i, 0] = i, para i = 0, m y D[0, j] = j, para i = 0, n.

• Proceso: La matriz se llena siguiendo la especificacion recursiva descritaen Ecuacion 5:

D(i, j) =

())*

))+

D(i$ 1, j $ 1) xi = yj

min(D(i$ 1, i$ 1),D(i$ 1, j),

D(i, j $ 1)) + 1 xi *= yj

(6)

De este modo, DE(X, Y ) = D(|X|, |Y |). Llenando la matriz apropiadamentetendremos un tiempo de O(m& n). El algoritmo se muestra en Alg 7.

7 Orden Estatico

Dado un arreglo A de tamano n no necesariamente ordenado, el objetivo esencontrar el k-esimo menor elemento en A, donde 1 # k # n. En otras palabras,se debe encontrar el elemento de la posicion k, si es que A se ordena previamente(esto se puede extender tambien al caso de buscar el k-esimo mayor.)

24 Jose M. Saavedra

7 ORDEN ESTATICO

Algorithm 7 DERequire: X, Y1: m % |X|2: n % |Y |3: D % crear matriz de (m + 1)& (n + 1)4: for i = 1 to m do5: for j = 1 to n do6: if xi = yi then7: D[i, j] = D[i$ 1, j $ 1]8: else9: D[i, j] = min(D[i$ 1, j $ 1], D[i, j $ 1], D[i$ 1, j]) + 1

10: end if11: end for12: end for13: return D[m,n]

7.1 Algoritmo QuickSelect

Este algoritmo es una extension del algoritmo de ordenacion QuickSort, proce-sando en cada llamada recursiva solamente una de las partes resutantes de laparticion. Una vez que el pivote queda ubicado, supogamos en la posicion p, talpivote no cambiara de posicion, entonces su orden estatico es p. Si k es menorque p, buscamos recursivamente en la parte izquierda, en otro caso buscaremosen la parte derecha el elemento de posicion k $ p. El algoritmo se presenta enAlg. 8.

Algorithm 8 QuickSelectRequire: A, izq, der, k1: piv % seleccionar pivote.2: p % particionar(A, izq, der, piv).3: p# % p$ izq + 14: if k = p# then5: return p6: else if k < p# then7: return QuickSelect(A, izq, p$ 1, k)8: else9: return QuickSelect(A, p + 1, der, k $ p#)

10: end if

El algoritmo QuickSelect tiene un tiempo promedio T (n) = T (n/2) + n,por lo que T (n) = O(n). Sin embargo, en el peor caso el pivote puede quedarprimero o ultimo, por lo que se descartarıa solamente un elemento necesitandobuscar recursivamente en los restantes n $ 1. Ası, en el peor caso se tieneT (n) = T (n$ 1) + n cuya complejidad es O(n2).

De igual modo que en el caso del algoritmo QuickSort, el punto crıtico en estealgoritmo es la seleccion del pivote. Algunas formas de minimizar la ocurrenciadel peor caso es seleccionar el pivote usando alguna de las siguientes heurısticas:

• Pivote aleatorio.

25 Jose M. Saavedra

6 Introducci´on al An´alisis de Algoritmosnbaloian/cc3001-02/Auxiliares/auxiliar2.pdf · 6...

Documents

Transcript of 6 Introducci´on al An´alisis de Algoritmosnbaloian/cc3001-02/Auxiliares/auxiliar2.pdf · 6...