6 Introducción al Análisis de Algoritmos

Transcripción

1 Quick_Sort(A,izq,k-1); Quick_Sort(A,k+1,der); fin_si En este caso, el algoritmo depende de la elección del pivote. Es recomendable determinar el pivote aleatoriamente para minimizar la probabilidad de la ocurrencia de malos casos. Pues Quick Sort tiene costo cuadrático en el peor caso. Sin embargo, en promedio, su desempeño práctico es mejor que Merge Sort. El costo promedio de Quick Sort también es O(nlogn). 6 Introducción al Análisis de Algoritmos Los algoritmos realizan un número de operaciones de acuerdo a la cantidad de datos (n) que procesan. El análisis de algoritmos consiste en determinar teóricamente el orden de la cantidad de estás operaciones. Cuando el número de operaciones es fijo o constante y no depende de n se dice que el algoritmo es de orden 1 y lo representaremos como O(1). En este sentido, un número fijo de asignaciones, multiplicaciones o comparaciones será de orden 1 (O(1)). En general definimos el número 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 Ryc>0. Por lo general, f(n) tiene un solo término (Ej, 1, n, n 2,2 n ) y es la menor función que cumple Eq.1. Entonces, si un algoritmo está asociado a un T (n) y T (n) =O(f(n)) diremos que el algoritmo es de orden f(n). Así podríamos tener 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 cuadrático, si T (n) =O(n 2 ). Algoritmo exponencial, si T (n) =O(a n ), para una constante a. Así, mientras menor sea el orden de los algoritmos, más eficientes son estos. Muchos algoritmos tienen un T (n) representado por un polinomio de la forma: T (n) =a 0 + a 1 n + a 2 n a p n p, en este caso el orden del algoritmo está gobernado por el orden del polinomio. Por lo tanto, T (n) =O(n p ). Por ejemplo, si un algoritmo tiene asociado un T (n) = 1 2 n2 + n 3, el algoritmo tiene orden cuadrático, es decir T (n) =O(n 2 ). Regla del Máximo: La regla del máximo dice que si T (n) =t 1 (n) +t 2 (n), siendo t 1 = O(f 1 (n)) y t 2 (n) =O(f 2 (n)), entonces T (n) =O(max(f 1 (n),f 2 (n))). 14 José M. Saavedra

2 6.1 Recurrencias Los algoritmos recursivos expresan su T (n) también en forma recursiva, como por ejemplo el número de operaciones del algoritmo Merge Sort está dado por: { ( 1 si n 1 T (n) = n ) 2T + n si n>1 2 Calcular el orden de un T (.) recursivo no es fácil, por lo que debemos transformar T (.) en una funcíon equivalente pero no recursiva. Este proceso se denomina resolución de recurrencia. Algunas estrategias para resolver la recurrencia se muestran a continuación Recurrencias Teléscopicas Las recurrencias telescópicas tienen la siguiente forma: X n+1 = a n + X n resolviendo X n hasta el caso base X 0 tenemos: X n+1 = X 0 + a 0 + a a n n X n+1 = X 0 + i=0 Ejercicios: Resolver las siguientes recurrencias: 1. T (n) = 2 n + T (n 1), donde T (0) = T (n) =T (n 1) + log 2 (n), donde T (0) = Cambios de variable En algunos casos, la forma telescópica no se observa directamente. Utilizando cambios de variable podemos hacer notoria la forma anterior y facilitar la resolución de la recurrencia. Por ejemplo, sea T (n) =2T ( n 2 )+n con el caso base T (n) = 1 cuando n 1. Para solucionar este problema supondremos que n =2 p, entonces tenemos: a i T (2 p )=2T (2 p 1 )+2 p La forma telescópicas no es notoria, pero veamos lo que ocurre si hacemos que T (2 p )=y(p), tedremos: y(p) =2y(p 1) + 2 p y luego dividimos todo por 2 p, haciendo que y(p)/(2 p )=r(p) tendremos r(p) =r(p 1) + 1 ahora sí tenemos la forma telescópica que al resolverla nos queda: p 1 r(p) = r(0) + 1 r(p) = 1 + p i=0 15 José M. Saavedra

3 Ahora obtenemos T (n) =y(p) =r(p)2 p =2 p + p2 p = O(nlogn), Ejercicios: Resolver las siguientes recurrencias: 1. T (n) = 2T (n 1) + 1, donde T (0) = Ecuación característica Sea la ecuación de la forma: a k T n+(k) + a k 1 T n+(k 1) + + a 0 T n =0 reemplazamos T n = λ n, y tenemos: λ n (a k λ k + a k 1 λ k a 0 λ 0 )=0 pero como λ n no puede ser 0, entonces: a k λ k + a k 1 λ k a 0 λ 0 =0. Ahora, tenemos k raíces: λ 1,..., λ k. Solución General: T n = c 1 λ n 1 + c 2 λ n c k λ n k Ejercicios: Resolver las siguientes recurrencias: 1. T (n) = 5T (n 1) 4T (n 2), donde T (1) = 3,T(2) = T (n + 1) = T (n)t (n 1), donde T (0) = 1,T(1) = Casos de Estudio En esta parte revisaremos algunos problemas interesantes con diferentes alternativas de solución usando estrategias como Divide & Conquista y Programación Dinámica Subsecuencia de Suma Máxima Sea Q = a 1,a 2,..., a n una secuencia de n enteros (posiblemente negativos), el objetivo es encontrar (i, j), 1 i j n, representando una subsecuencia j contigua a i,..., a j en Q, tal que a k sea la mayor para cualquier i, j. Visto k=i desde el punto de vista de optimización sería: argmax 1 i j n ( j k=i a k ). Si para todo a Q, a < 0 entonces la suma máxima es 0. Ejemplo: S =-2, 11, -4, 13, José M. Saavedra

4 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 0 2: for i = 1 to n do 3: for j = i to n do 4: s 0 5: for k = i to j do 6: s s + a k 7: if s > smax then 8: smax s 9: i i 10: j j 11: end if 12: end for 13: end for 14: end for 15: return [smax, i,j ] El algoritmo mostrado en Alg. 1 es un algoritmo ingenuo, muy ineficiente, n n j cuyo tiempo está dado por: T = 1, dando un orden O(n 3 ). i=1 j=i k=i Algoritmo de Fuerza Bruta Mejorado Podríamos hacer algo mejor que lo anterior al notar que para un i fijo estamos recalculando sumas al variar j. Es decir, podemos evitar una ciclo iterativo si evitamos recalcular la suma desde i hasta j 1 para un nuevo valor de j. Así, tendríamos el siguiente algoritmo: n n Ahora tenemos un algoritmo con T = 1 de orden cuadrático O(n 2 ). i=1 j=i Algoritmos Divide & Conquista Es posible aún obtener una mayor eficiencia si dividimos el problema en dos subproblemas, resolviéndolos por separado, para finalmente obtener una solución mezclando ambas soluciones parciales (principio divide & conquista). Entonces, dada la secuencia Q, la dividimos en mitades como se muestra en la Figura 1. Luego resolvemos por separado cada mitad. Llamemos m 1 a la ssm de la izquierda y m 2 a la correspondiente suma de la derecha. Además, supongamos que m1 corresponde a la subsecuencia que va dese p hasta q, mientras que m2 corresponde a la subsecuencia que va desde r hasta s. Tenemos dos soluciones, la pregunta ahora es cómo mezclar ambas?. Para obtener el resultado final, tenemos que notar que al descomponer la secuencia en dos partes dejamos de evaluar el comportamiento de las subsecuencias que cruzan el centro. Por lo tanto, debemos encontrar la ssm que pasa 17 José M. Saavedra

5 Algorithm 2 Algoritmo de fuerza bruta para SSM mejorado 1: smax 0 2: for i = 1 to n do 3: s 0 4: for j = i to n do 5: s s + a j 6: if s > smax then 7: smax s 8: i i 9: j j 10: end if 11: end for 12: end for 13: 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. Llamemos x a esta última ssm. El resultado final es max(x, m 1,m 2 ). El Alg. 3 describe el algoritmo completo. Ahora, tenemos un tiempo recursivo de T (n) = 2T (n/2) + O(n), que al resolverlo nos da T (n) = nlog(n). Por lo tanto, tenemos un algoritmo de orden O(nlogn), mucho más eficiente que los dos previamente discutidos. Habrá un algoritmo más eficiente?. Algoritmo SSM Lineal Podemos llegar a un orden lineal para resolver el problema de subsecuencia de suma máxima. Definamos primero la siguiente aserción: La mejor subsecuencia no puede comenzar con un número negativo. En general, ninguna subsecuencia de suma negativa puede ser prefijo de la subsecuencia óptima. El algoritmo se basa en dos invariantes para cada posición 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 valores antes descritos, respectivamente. Inicialmente, ambas variables son cero. Cuando la mejor subsecuencia que termina en j se hace negativa, reseteamos la segunda variable, pues ninguna subsecuencia que termina en j puede ser parte 18 José M. Saavedra

6 Algorithm 3 SSM DC Require: Q : a1,..., a n ; izq, der 1: centro izq+der 2 2: if izq = der then 3: if a izq < 0 then 4: return [0, 1, 1] 5: else 6: return [a izq, izq, der] 7: end if 8: else 9: [m 1, p, q] SSM DC(Q, izq, centro) 10: [m 2, r, s] SSM DC(Q, centro +1, der) 11: sp 0; 12: max izq 0; 13: x izq 1 14: for i = centro down to p (p >0) do 15: sp sp + a i 16: if sp > max izq then 17: max izq sp 18: x izq i 19: end if 20: end for 21: sp 0 22: max der 0 23: x der 1 24: for i = centro + 1 to s do 25: sp sp + a i 26: if sp > max der then 27: max der sp 28: x der i 29: end if 30: end for 31: ssm = max(m 1,m 2, max izq + max der ) 32: if m 1 = ssm then 33: return [m 1, p, q] 34: else 35: if m 2 = ssm then 36: return [m 2, r, s] 37: else 38: return [max izq + max der,x izq,x der ] 39: end if 40: end if 41: end if de la subsecuencias buscada. El algoritmo en Alg. 4 describe la propuesta lineal. Es fácil notar que el algoritmo mostrado en Alg. 4 tiene un tiempo de ejecución de orden O(n). 19 José M. Saavedra

7 Algorithm 4 Algoritmo lineal para SSM 1: ssm 0 2: sp 0 3: i 0 0 4: for j = 1 to n do 5: sp sp + a j 6: if sp > ssm then 7: ssm sp 8: i i : j j 10: else if sp < 0 then 11: sp 0 12: i 0 j 13: end if 14: end for 15: return [ssm, i,j ] Multiplicación de Matrices Dadas dos matrices cuadradas A, B de N N (si A y B tienen diferentes dimensiones 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 columna de B, obtener el producto punto de la fila i en A y columna j en B, el resultado es asignado a la posición i, j en C. Esto toma tiempo O(N 3 ), el algoritmo se muestra en Alg. 5. Algorithm 5 Algoritmo tradicional para multiplicar matrices 1: for i = 1 to N do 2: for j = 1 to N do 3: s 0 4: for k = 1 to N do 5: s A[i][k] B[k][j]+s 6: end for 7: C[i][j] s 8: end for 9: end for Algoritmo Divide & Conquista Supongamos que dividimos las matrices en cuatro zonas, tal como se muestra en la Figura 2. En este caso tenemos 8 subproblemas a resolver cuyas soluciones componen la solución final de la siguiente manera: C 11 = A 11 B 11 + A 12 B 21 C 12 = A 11 B 12 + A 12 B José M. Saavedra

8 Figure 2: Esquema divide y conquista para la multimplicación de matrices. C 21 = A 21 B 11 + A 22 B 21 C 22 = A 21 B 12 + A 22 B 22 La composición final toma tiempo O(N 2 ). Sin embargo, este algoritmo tiene un tiempo recursivo de T (N) =8T (N/2) + O(N 2 ) cuyo orden sigue siendo cúbico, O(N 3 ). Algoritmo de Strassen Strassen propuso en 1969 una forma de calcular el producto de matrices basada en la estrategia divide & conquista, como se describió anteriormente, pero en la que solamente se necesitan resolver 7 subproblemas. La propuesta es la siguiente: M 1 =(A 12 A 22 )(B 21 + B 22 ) M 2 =(A 11 + A 22 )(B 11 + B 22 ) M 3 =(A 11 A 21 )(B 11 + B 12 ) M 4 =(A 11 + A 12 )B 22 M 5 = A 11 (B 12 B 22 ) M 6 = A 22 (B 21 B 11 ) M 7 =(A 21 + A 22 )B 11 La composición de la solución final está dada por: C 11 = M 1 + M 2 M 4 + M 6 C 12 = M 4 + M 5 C 21 = M 6 + M 7 C 22 = M 2 M 3 + M 5 M 7 Esta solución tiene un tiempo recursivo de T (N) = 7T (N/2) + O(N 2 ) cuyo orden es O(7 log2n ) O(N 2.81 ). La complejidad asintótica de este algoritmo es ligeramente menor que la del algoritmo tradicional para multiplicar matrices. Sin embargo, en la práctica el algoritmo de Strassen funciona mucho mejor. 21 José M. Saavedra

9 6.2.3 Subsecuencia Común más larga En los dos casos anteriores hemos visto cómo aplicar la estrategia Divide & Conquista en la solución de problemas. Ahora veremos cómo aplicar la Programación Dinámica en el problema de la Subsecuencia Común más larga (LCS). LCS es uno de los problemas con muchas aplicaciones en Bioinformática, como por ejemplo encontrar patrones similares en secuencias de ADN. En términos generales, el objetivo de LCS es econtrar la subsecuencia (no necesariamente contigua) común más larga entre dos secuencias (ej. strings). Sea X, Z dos secuencias de largo m y n, respectivamente. Por simplicidad pensemos en secuencias de carácteres: X = x 1,x 2,..., x m Z = z 1,z 2,..., z n diremos, en este problema, que Z es una subsecuencia de X, si existe una secuencia i 1,..., i n, t.q. i j es una posición en X, en donde se cumple: i j <i j+1 j =1... n 1y x ij = z j j =1... n. Problema: Dados 2 strings X, Y encontrar la subsecuencia Z de mayor longitud común a X e Y. Algoritmo de Fuerza Bruta El algoritmo de fuerza bruta requiere calcular todas las subsecuecias de X y de Y, para luego buscar la común de mayor longitud. Calcular todas las subsecuencias de un string X es como calcular el conjunto potencia del conjunto de símbolos de X, en el que cada símbolo es considerado diferente al resto. Así, el tiempo requerido para este cálculo es O(2 X ), lo que lo hace inaplicable. Algoritmo Recursivo Sea X i el i-ésimo prefijo del string X, es decir: X i = x 1,x 2,... x i donde, 0 i m, siendo m = X y X = X m. Además definimos, X 0 = ε (cadena vacía). Así, LCS(X, Y ) = LCS(X m,y n ) y se sigue la siguiente definición recursiva: LCS(X i 1,Y j 1 ) x i si x i = y j LCS(X i,y j )= argmax( LCS(X i,y j 1 ), LCS(X i 1,Y j ) ) en otro caso. (2) donde, indica concatenación. Implementar la solución recursiva es muy caro, también de orden exponencial. Sin embargo, el uso de programación dinámica nos permite implementar la solución recursiva eficientemente. Algoritmo basado en Programación Dinámica 22 José M. Saavedra

10 Considerando la solución recursiva anterior, definimos L como una matriz de tamaño (m + 1) (n + 1), en donde L[i, j] = LCS(X i,y j ). Inicialmente, L[i, 0] = L[0,j]=0 i =0,..., m; j =0...., n. Luego, la matriz L es llenada de la siguiente manera: L[i 1,j 1] + 1 si x i = y j L[i, j] = (3) max(l[i, j 1],L[i 1,j]) en otro caso. 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 a partir L[m.n], retrocedemos por donde se encontró los máximos valores o por la diagonal, recuperando lo símbolos correspondientes. Para ello, necesitamos un matriz adicional B de tamaño (m + 1) (n + 1), que almacene la dirección de retorno, como se muestra a continuación. B[i, j] =D si x i = y i B[i, j] = B[i, j] =I si L[i, j 1] >L[i 1,j] (4) B[i, j] =A si L[i, j 1] <L[i 1,j] A: arriba, D: diagonal, I: izquierda. Un algoritmo simple para recuperar LCS(X, Y ), dados B, X e Y es el que se muestra en Alg. 6. En este caso, el algoritmo se basa en llenar las matrices L y B, por lo que el tiempo de ejecución es de orden O(m n). Algorithm 6 Recuperar LCS Require: X, Y, B, i, j 1: s ε 2: if i! = 0ANDj! = 0 then 3: if B[i, j] = A then 4: s Recuperar LCS(X, Y, B, i 1,j) 5: else if B[i, j] = I then 6: s Recuperar LCS(X, Y, B, i, j 1) 7: else 8: s Recuperar LCS(X, Y, B, i 1,j 1) X[i] 9: end if 10: end if 11: return s En la Figura 3 se muestra un ejemplo de la solucióm de LCS usando programación dinámica Distancia de Edición entre Cadenas Otro problema interesante es el de comparar cadenas usando una distancia que nos dice que tan diferentes son dos cadenas. Para eso existe un algoritmo famoso que se denomina Distancia de Edición o Distancia de Levenshtein cuyo funcionamiento se describe a continuación. Sean X = x 1,x 2,... x m y Y = y 1,y 2,..., y n dos cadenas (strings) de largo m y n respectivamente, la distancia de edición entre X, Y se define como el 23 José M. Saavedra

11 7 ORDEN ESTÁTICO Figure 3: En la derecha se muestra la matriz L, mientras que en la izquierda aparece la matriz B. El texto recuperado se muestra de color verde. mínimo número de operaciones elementales que hay que realizar para convertir una cadena en la otra. Las operaciones elementales son de tres tipos: (1) Inserción, cuando se agrega un caracter a una de las cadenas, (2) Eliminación, cuando se quita un caracter de una de las cadenas, y (3) Sustitución, si un caracter se cambia por otro. Además definimos X i como la subcadena con los primeros i caracteres de la cadena X. Así, X i = x 1,... x i. La distancia de edición entre X i e Y j, DE(X i,y j ) se define recursivamente como: DE(X i 1,Y j 1 ) x i = y j min(de(x DE(X i,y j )= i 1,Y i 1 ), (5) DE(X i 1,Y i ), DE(X i,y i 1 )) + 1 x i y j donde DE(X 0,Y i )=i ó DE(X i,y 0 )=i. Finalmente, DE(X, Y )=DE(X m,y n ). Solucionar este problema en forma recursiva resulta en un algoritmo ineficiente. La forma de atacar este problema es usando Programación Dinámica. En este sentido definimos una matriz D de (m+1) (n+1) celdas, donde D[i, j] almacena la distancia de edición calculada entre X i e Y j. Inicialización: D[i, 0] = i, para i =0,m y D[0,j]=j, para i =0,n. Proceso: La matriz se llena siguiendo la especificación recursiva descrita en Ecuación 5: D(i 1,j 1) x i = y j min(d(i 1,i 1), D(i, j) = (6) D(i 1,j), D(i, j 1)) + 1 x i y j De este modo, DE(X, Y ) = D( X, Y ). Llenando la matriz apropiadamente tendremos un tiempo de O(m n). El algoritmo se muestra en Alg 7. 7 Orden Estático Dado un arreglo A de tamaño n no necesariamente ordenado, el objetivo es encontrar el k-ésimo menor elemento en A, donde 1 k n. En otras palabras, se debe encontrar el elemento de la posición k, si es que A se ordena previamente (esto se puede extender también al caso de buscar el k-ésimo mayor.) 24 José M. Saavedra

12 7 ORDEN ESTÁTICO Algorithm 7 DE Require: X, Y 1: m X 2: n Y 3: D crear matriz de (m + 1) (n + 1) 4: for i = 1 to m do 5: for j = 1 to n do 6: if x i = y i then 7: D[i, j] =D[i 1,j 1] 8: else 9: D[i, j] =min(d[i 1,j 1],D[i, j 1],D[i 1,j]) : end if 11: end for 12: end for 13: return D[m,n] 7.1 Algoritmo QuickSelect Este algoritmo es una extensión del algoritmo de ordenación QuickSort, procesando en cada llamada recursiva solamente una de las partes resutantes de la partición. Una vez que el pivote queda ubicado, supogamos en la posición p, tal pivote no cambiará de posición, entonces su orden estático es p. Si k es menor que p, buscamos recursivamente en la parte izquierda, en otro caso buscaremos en la parte derecha el elemento de posición k p. El algoritmo se presenta en Alg. 8. Algorithm 8 QuickSelect Require: A, izq, der, k 1: piv seleccionar pivote. 2: p particionar(a, izq, der, piv). 3: p p izq +1 4: if k = p then 5: return p 6: else if k < p then 7: return QuickSelect(A, izq, p 1, k) 8: else 9: 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 quedar primero o último, por lo que se descartaría solamente un elemento necesitando buscar recursivamente en los restantes n 1. Así, en el peor caso se tiene T (n) =T (n 1) + n cuya complejidad es O(n 2 ). De igual modo que en el caso del algoritmo QuickSort, el punto crítico en este algoritmo es la selección del pivote. Algunas formas de minimizar la ocurrencia del peor caso es seleccionar el pivote usando alguna de las siguientes heurísticas: Pivote aleatorio. 25 José M. Saavedra