DividirYConquistar 4x1

Algoritmos y Complejidad Algoritmos y Complejidad
Algoritmos “dividir y conquistar”
Introducción
Algoritmos y Complejidad
Ordenamiento: mergesort y quicksort
Algoritmos “dividir y conquistar”
Elemento mediano
Pablo R. Fillottrani
Multiplicación de matrices
Depto. Ciencias e Ingeniería de la Computación
Universidad Nacional del Sur
Par de puntos más cercanos
Primer Cuatrimestre 2017
Criptografía – exponenciación modular
Transformada Rápida de Fourier (FFT)

Introducción Introducción
Generalidades Generalidades
Generalidades
I “dividir y conquistar” (DYC) es un técnica de diseño de algoritmos I es importante entonces determinar para cada problema:
que consiste en 1. cuáles son las subinstancias, y cómo se encuentran
1. descomponer la instancia del problema a resolver en un conjunto 2. cómo solucionar el problema en las subinstancias
de instancias más pequeñas del mismo problema 3. cómo combinar las soluciones parciales
2. resolver independientemente cada una de estas subinstancias. I para el punto 2. se puede aplicar nuevamente la técnica DYC,
No se guardan resultados de instancias previamente calculadas,
hasta que se llegue a subinstancias de tamaño suficientemente
como en PD.
3. combinar estas soluciones en una solución a la instancia original. pequeño para ser resueltas inmediatamente.
I es probable que esta técnica resulte en un algoritmo más
eficiente que el original.
Esquema General
function DYC(x)
IF x es suficientemente simple I se debe especificar cuáles son el algoritmo básico, el de
RETURN algoritmoBasico(x) descomposición y el de combinación
ELSE I también se necesita determinar cuándo una instancia es
descomponer x en x[1],x[2],...,x[s] suficientemente simple como para dejar de aplicar la división
FOR i ::= 1 TO s
I si se trata de tamaño, este valor se denomina umbral
y[i] ::= DYC(x[i])
ENDFOR
combinar y[i] en una solución y a x
RETURN y
ENDINF

Análisis general del tiempo de ejecución
I el tiempo de ejecución está determinado por la recurrencia: I los métodos vistos para resolver recurrencias brindan soluciones
a la mayoría de las recurrencias generadas por algoritmos DYC.
f (n) si n es simple I en especial el método del teorema maestro.
TDYC (n) =
sTDYC (n ÷ b) + g (n) sino
I para que DYC sea eficiente las subinstancias deben ser todas de
donde aproximadamente el mismo tamaño.
I n = |x |
I además, se debe estudiar cuidadosamente cuál o cuáles son los
I b es una constante tal que n ÷ b aproxime el tamaño de las
mejores umbrales.
subinstancias
I f (n) es el tiempo de algoritmoBásico()
I g (n) es el tiempo de la partición y combinación.
Determinación del umbral
I la determinación del umbral no afecta en general el orden del

tiempo de ejecución de los algoritmos DYC
I cambiando el umbral se obtienen los siguientes tiempos
absolutos:
I pero sí afecta considerablemente las constantes ocultas
I ejemplo n TDyC con n0 = 1 TDyC con n0 = 64 Algoritmo básico
5000 41 seg 6 seg 25 seg
n2 µseg

si n ≤ n0 32000 15 min 2min 15 min
TDyC =
3TDyC (bn/2c) + 16n µseg sino
suponiendo el algoritmo directo de Θ(n2 )

I entonces resulta TDYC (n) ∈ Θ(nlog 3 )

Correctitud
I es muy difícil, o a veces imposible, encontrar teóricamente un
umbral optimal (ya sea para cada instancia o incluso para cada
n).
I puede pasar que el umbral óptimo cambia de instancia en I a diferencia de los algoritmos greedy, es fácil probar la
instancia, y que dependa de cada implementación en particular. correctitud de los algoritmo DYC
I también es poco práctico encontrar empíricamente una I se supone la correctitud del algoritmo básico, y se prueba por
aproximación a un buen umbral: sería necesario ejecutar el inducción sobre el tamaño de la instancia que la solución
algoritmo muchas veces en una gran cantidad de instancias obtenida es correcta suponiendo la correctitud de las instancias
I la solución generalmente tomada es un camino híbrido: más chicas
1. se encuentra la función exacta del tiempo de ejecución de los I no vamos a ver en detalle ninguna prueba de correctitud para
algoritmos (no alcanza con conocer sólo el orden!) dando valores DYC, pero no son difíciles de hacer
a las constantes de acuerdo pruebas empíricas.
2. se toma como n0 un valor en el cual tome aproximadamente el
mismo tiempo el algoritmo directo que el DyC
Multiplicación de enteros grandes Multiplicación de enteros grandes
MULTIPLICACION DE ENTEROS GRANDES
I Problema: supongamos que tenemos que multiplicar dos enteros I si se implementa cualquiera de los algoritmos tradicionales para
a y b, de n y m dígitos cada uno, cantidades que no son posibles el producto entre dos números cualesquiera, el resultado es de
de representar directamente por el HW de la máquina Θ(nm)
I es fácil implementar una estructura de datos para estos enteros I aplicaremos DYC para tratar de mejorar este tiempo. Suponiendo
grandes, que soporte por el momento que n = m
1. suma de Θ(n + m).
2. resta de de Θ(n + m).
3. productos y divisiones por la base de Θ(n + m).

I aplicando DYC una sola vez, y usando base 10 se tiene: I si se extiende el método aplicando DYC recursivamente se
a x y b w z obtiene la recurrencia:
Θ(n2 )

dn/2e bn/2c dn/2e bn/2c si n ≤ n0
tDyC (n) =
I esto es: 4tDyC (dn/2d) + Θ(n) sino
I el resultado no es bueno (aplicar el teorema maestro!)
a×b = (x10bn/2c + y) × (w10bn/2c + z) = I el principal problema es que se necesitan cuatro productos más
= xw102bn/2c + (xz + wy)10bn/2c + yz pequeños.
I se puede reducir esta cantidad de productos, observando
r = (x + y)(w + z) = I si el tiempo del algoritmo directo es an2 + bn + c y el de la

sobrecarga es g (n), entonces aplicando DYC una sóla vez se
= xw + (xz + yw) + yz
obtiene
I con lo que resulta
(xz + yw) = r − xw − yz T (n ) = 3a(bn/2c)2 + 3bbn/2c + 3c + g (n)

≤ (3/4)an2 + (3/2)bn + 3c + g (n)
I y también
a×b = xw102bn/2c + (r − xw − yz)10bn/2c + yz I comparado con an2 + bn + c es sólo una mejora del 25 % en la
constante del término principal, pero igualmente es de Θ(n2 )
I se tiene entonces dos productos de bn/2c dígitos, un producto
de a lo sumo bn/2c + 1 dígitos, más sumas, restas y productos
de potencias de la base.

I para obtener una mejora asintótica es preciso aplicar DYC I se puede deducir de esta recurrencia que
recursivamente a los productos más pequeños TDyC (n) ∈ O (nlog 3 |n = 2k ), usando otra vez el teorema maestro.
I el tiempo de este algoritmo genera la siguiente recurrencia: I como TDyC (n) es eventualmente no decreciente y nlog 3 es de
 crecimiento suave, entonces TDyC (n) ∈ O (nlog 3 ), aplicando la
Θ(n2 ) si n es pequeño
regla de las funciones de crecimiento suave.

TDyC (n) = TDyC (bn/2c) + TDyC (dn/2e)+

+TDyC (bn/2c + 1) + Θ(n) sino
I análogamente se puede mostrar que TDyC (n) ∈ Ω(nlog 3 )
(ejercicio).
I si m 6= n pero ambos son de la misma magnitud, entonces es

posible completar el número más chico con ceros hasta llegar al
I restaría determinar cuál es el tamaño suficientemente pequeño tamaño del más grande
para que convenga aplicar el algoritmo directo. ¿Cómo podría
I pero esta solución no siempre es buena.
hacerse?
I ¿cómo aprocechar mejor la misma técnica si m << n? (ejercicio
I usando el método híbrido, encontrando la intersección entre el
Ayuda: partir los números en pedazos de a m)
tiempo DYC y el tiempo del algoritmo básico
I en este caso se puede obtener un resultado de Θ(nmlog (3/2) ),
que es asintóticamente mejor que Θ(nm), o que Θ(nlog 3 ) si
m << n

Búsqueda binaria Búsqueda binaria
BÚSQUEDA BINARIA
I un algoritmo naïve para resolver BÚSQUEDA BINARIA es:

I Problema: dado un arreglo de enteros T [1..n], ordenado en
forma creciente, y un entero x, se quiere encontrar el índice i tal function BúsquedaSecuencial(T[1..n],x)
que T [i − 1] < x ≤ T [i ] FOR i ::= 1 TO n
I por simplicidad se supone la convención de que T [0] = −∞ y IF T[i]>=x
T [n + 1] = +∞. RETURN i
ENDIF
I el tradicional algoritmo de búsqueda binaria puede verse como
ENDFOR
una degeneración de algoritmos DyC, en donde la cantidad de
RETURN n+1
subinstancia es 1
I en estos casos la técnica DYC se denomina simplificación
Búsqueda binaria Búsqueda binaria
function BúsqBinaria(T[i..j],x)
I este algoritmo naïve tiene tiempo Θ(n) en el peor caso, y Θ(1) IF i=j
en el mejor caso RETURN i
ELSE
I si todas las instancias del arreglo tienen igual probabilidad de ser
k ::= (i+j) div 2
llamadas, entonces el tiempo promedio también es de Θ(n)
IF x<=T[k]
I para aplicar DYC se determina en cuál mitad del arreglo debería
RETURN BúsqBinaria(T[i..k],x)
estar x, comparándolo con el elemento del medio
ELSE
I luego se busca recursivamente en esa mitad RETURN BúsqBinaria(T[k+1..n],x)
ENDIF
ENDIF

Introducción Ordenamiento: mergesort y quicksort
Búsqueda binaria Mergesort
Análisis del tiempo de ejecución Mergesort
I sea m = j − i + 1. El tiempo de ejecución genera la recurrencia:

I mergesort es el algoritmo “obvio” para el ordenamiento de un
a si m = 1 arreglo usando DYC.
T (m) ≤
b + t (dm/2e) sino
I consiste en partir el arreglo en dos mitades, ordenar cada una de
I resolviendo se obtiene T (m) ∈ Θ(log m) en el peor caso las mitades por separado y hacer una mezcla de estas mitades
ya ordenadas.
I el mismo resultado se obtiene aún en el mejor caso. ¿cómo se
puede modificar el algoritmo para mejorar este punto?
Ordenamiento: mergesort y quicksort Ordenamiento: mergesort y quicksort
Mergesort Mergesort
Mergesort(A[1..n])
IF n es pequeño
RETURN Inserción(A)
I la partición consiste en la creación de dos mitades del arreglo
ELSE original
crear A1 y A2 subarreglos de A I la combinación es la mezcla de las mitades ordenadas
B1 ::= Mergesort(A1) I hay que tener cuidado con el manejo de los parámetros, para
B2 ::= Mergesort(A2) evitar duplicar los arreglos. En este caso se pasarán los índices
Mezcla(B1, B2, B)
RETURN B
ENDIF

Mergesort Mergesort
I informalmente, el tiempo de ejecución está determinado por la

recurrencia:
I según el método del teorema maestro, el resultado es de
Θ(1) si n es pequeño O (n log n), en el mismo orden que heapsort
T (n) =
2T (n ÷ 2) + Θ(n) sino I para una demostración formal, habría que resolver la recurrencia
I donde: T (n) = T (bn/2c) + T (dn/2e) + Θ(n), que también da de
I Θ(1) es el tiempo de Inserción(), que es ser acotado por una Θ(n log n).
constante suficientemente grande porque vale cuando n es
pequeño
I Θ(n) es el tiempo de la partición y de la mezcla
Mergesort Mergesort
Ejercicios
I es fundamental para que el tiempo sea de Θ(n log n) que las dos
subinstancias en las que se parte el problema sean de tamaño
semejante
I ¿qué pasa si se divide el problema original en subinstancias de
I en el caso extremo de partir en subinstancias de tamaño
tamaño k y n − k , con k constante?
desparejo, la recurrencia sería
I ¿qué pasa si se divide el problema original en tres subinstancias

 Θ(n2 ) si n ≤ n0 de tamaño semejante?
T (n) = T (n − 1) + T (1) + Θ(n) = I ¿qué pasa si la partición o la combinación toman tiempo de
= T (n − 1) + Θ(n) sino

Θ(n2 ) en lugar de Θ(n)?
que resulta T (n) ∈ Θ(n2 ).

Quicksort Quicksort
Quicksort
I a diferencia de mergesort, que hace una descomposición trivial costo

pero con una recombinación costosa, el algoritmo quicksort Quicksort(A[i..j])
(Hoare) pone énfasis en la descomposición IF j-i es pequeño c
I la partición del arreglo a ordenar se realiza eligiendo un elemento Inserción(A[i..j]) Θ(1)
(el pivote), y luego partiendo en dos subarreglos con los ELSE
elementos menores o iguales al pivote, y con lo elementos piv ::= A[i] c
mayores que el pivote. Pivotear(A[i..j],piv,l) Θ(n)
I estos nuevos arreglos son ordenados en forma recursiva, y Quicksort(A[i..l-1])
directamente concatenados para obtener la solución al problema Quicksort(A[l+1..j])
original. ENDIF T (n − 1) peor caso
I es posible obtener una implementación del pivoteo en tiempo de
Θ(n), incluso realizando una sola recorrida al arreglo
Quicksort Quicksort
Algoritmo de pivoteo
Primera parte: encontrar los dos primeros elementos para

intercambiar
I el tiempo de ejecución es
Pivotear(A[i..j],piv,var l)
Θ(1) si n es pequeño k ::= i; l ::= j+1
T (n ) =
T (n − 1) + Θ(n) sino REPEAT
k ::= k+1
I usando la ecuación característica, T (n) ∈ Θ(n2 ).
UNTIL A[k]>piv or k>j
REPEAT
l ::= l-1
UNTIL A[l]<=piv
...

Quicksort Quicksort
Segunda parte: si existen esos elementos, intercambiarlos y encontrar

los siguientes elementos para intercambiar
...
WHILE k<l I el total de iteraciones es l − i + 1 para k y j + 1 − l para j
intercambiar A[k] y A[l] I luego en total de iteraciones es de Θ(j − i )
REPEAT I como el tiempo del cuerpo de los ciclos es constante, el tiempo
k ::= k+1 total es entonces de Θ(j − i )
UNTIL A[k]>piv
REPEAT
l ::= l-1
UNTIL A[l]<=piv
ENDWHILE
Quicksort Quicksort
Análisis probabilístico
I el tiempo promedio está definido entonces por la recurrencia:
n−1
1
I se puede probar que el tiempo promedio del quicksort es de Tprom (n) = ( ∑ Θ(n) + Tprom (k ) + Tprom (n − 1 − k )) =
n k =0
Θ(n log n), asignando igual probabilidad a todos los arreglos
I supongamos que todas las n! instancias tienen igual probabilidad 2 n−1
= Θ(n) + ∑ Tprom (k ) =
de ser llamadas, y que todos los elementos de T son distintos n k =0
n−1
I esto implica que el pivote cae con igual probabilidad en cada una 2
= Θ(n) + [Tprom (0) + Tprom (1) + ∑ Tprom (k )] =
de las posiciones del arreglo a ordenar; y también que cada uno n k =2
de las subinstancias generadas heredan una distribución
2 n−1
uniforme. = Θ(n) + ∑ Tprom (k )
n k =2

Quicksort Quicksort
I con el objetivo de mejorar el tiempo de ejecución en el peor caso

de quicksort para llevarlo a Θ(n log n) se podría implementar una
Teorema 1 mejor elección del pivote
Quicksort tiene tiempo promedio en O (n log n). I se podría elegir cómo pivote el elemento mediano (aquel que
estaría en la posición del medio una vez ordenado el arreglo),
Prueba.
que parte al arreglo en dos mitades semejantes.
Por inducción constructiva se encuentran los valores para c tal que
Tprom (n) ≤ cn log n.
I pero esto no siempre es así si el arreglo tiene elementos
repetidos.
I luego se necesita además partir el arreglo en tres partes
(menores, iguales y mayores), no sólo en dos
Quicksort Quicksort
Algoritmo de pivoteo de la bandera holandesa

I en resumen, para que quicksort sea de tiempo Θ(n log n) en el
peor caso se requiere: function PivoteoBH(p,var T[i..j],k,l)
I una mejor elección del pivote, que asegure subarreglos de k ::= i-1; m ::= i; l ::= j+1
tamaño semejante, pero siempre en tiempo Θ(n). WHILE m<l
I modificar el pivotear para partir el arreglo en tres subarreglos: los CASE
elementos menores, los elementos iguales y los elementos T[m]=p: m ::= m+1
mayores que el pivote. T[m]>p: l ::= l-1; swap(T[m],T[l])
I estas “mejoras” involucran constantes ocultas que hacen del T[m]<p: k ::= k+1; swap(T[m],T[k])
algoritmo resultante practicamente inviable comparado con la m ::= m+1
versión naïve. ENDCASE
I se verá a continuación primero el nuevo algoritmo de pivoteo, y ENDWHILE
luego cómo mejorar la elección del pivote.
I el tiempo es de Θ(n); es más, sólo recorre al arreglo una vez
(ejercicio).

Ordenamiento: mergesort y quicksort Elemento mediano
Quicksort
SELECCCIÓN ELEMENTO MEDIANO
I también se puede elegir el pivote al azar, resultando en una I Problema: se tiene un arreglo A[1..n] de enteros, no
versión probabilística de Quicksort con tiempo esperado de necesariamente ordenado, y se quiere encontrar el elemento
Θ(n log n) mediano.
I la ventaja de esta versión es que no existe una instancia en la I éste es el elemento que estaría en la posición dn/2e si el arreglo
que tarde más, sino que ciertas ejecuciones sobre cualquier estuviera ordenado.
instancia son las que llevan el peor caso I si el elemento mediano es elegido como pivote cuando no hay
elementos repetidos, se asegura la partición del arreglo en
subarreglos de tamaño semejante
Elemento mediano Elemento mediano
Selección
SELECCIÓN
I la solución obvia a este problema es ordenar el arreglo y devolver

I Problema: se tiene un arreglo A[1..n] de enteros, no
A(dn/2e)
necesariamente ordenado, y un entero s, 1 ≤ s ≤ n. Se quiere
I pero su tiempo de ejecución es de Θ(n log n), y eso no mejoraría encontrar el elemento s-ésimo.
quicksort (ejercicio)
I el s-esimo elemento es el elemento que estaría en la posición s
I para mejorar asintóticamente este tiempo, se solucionará un de estar el arreglo ordenado
problema más general, denominado SELECCIÓN.
I SELECCIÓN y MEDIANO son equivalentes (existen reducciones
en ambas direcciones).

Selección Selección
Reducciones Reducción SELECCIÓN −→ MEDIANO
function Selección(A[i..j],s)
p ::= Mediano(A[i..j])
PivotearBH(p,A[i..j],k,l)
I la reducción MEDIANO −→ SELECCIÓN es trivial, basta con
CASE
llamar a SELECCIÓN con s = dn/2e.
s<=k: j ::= k
I la reducción SELECCIÓN −→ MEDIANO tampoco es difícil, ya r ::= Selección(T[i..j],s)
que es muy parecida al algoritmo de búsqueda binaria k<s<l: r ::= p
s>=l: i ::= l
r ::= Selección(T[i..j],s-l+1)
ENDCASE
RETURN r
I a partir de este algoritmo, cambiando la elección del pivote, se

I la cantidad de llamadas recursivas es de Θ(log n), similar a la puede asegurar un peor tiempo lineal para SELECCIÓN
búsqueda binaria I el pivote no necesariamente es exactamente el mediano.
I se puede transformar en un algoritmo iterativo sin problemas. I esta solución también servirá para nuestro problema original:
MEDIANO

Costo Veces
I se necesita entonces un algoritmo eficiente para seleccionar un function PseudoMediano(A[1..n])
elemento que divida al arreglo ordenado en partes IF n<=5
“suficientemente” parejas. p ::= MedAdhoc5(A[1..n]) a 1
ELSE
I Ejercicio: Sea TS (n) el tiempo del algoritmo de SELECCIÓN.
z ::= piso(n/5) b 1
Supongamos que seleccionar el pivote lleva tiempo TS (n/b),
array Medianos[1..z]
para algún b natural, b ≤ 9. ¿cuán “suficientemente” buena, en
FOR i ::= 1 TO z
función de b, tendría que ser la división del arreglo? (Ayuda: usar
Medianos[i] ::=
las propiedades de las recurrencias.)
MedAdhoc5(A[5i-4..5i]) c bn/5c
I el siguiente algoritmo encuentra una aproximación al mediano ENDFOR
con tiempo de ejecución en Θ(TS (bn/5c) + bn/5c). p ::= Selección(Medianos[1..z],
techo(z/2)) TS (bn/5c) 1
ENDIF; RETURN p
Costo
function Selección(A[i..j],s)
I donde MedAdhoc5() es un algoritmo para encontrar el p ::= PseudoMediano(A[i..j]) Θ(n) + tS (bn/5c)
mediano de a los sumo 5 elementos PivotearBH(p,A[i..j],k,l) Θ(n)
I y por lo tanto es de tiempo Θ(1). CASE
I el tiempo de ejecución de Pseudomediano() es s<=k: r::=Selección(A[i..k],s) TS (k − i + 1)
Θ(n) + TS (bn/5c), donde TS () es el tiempo de ejecución del k<s<l: r::=p Θ(1)
algoritmo para resolver el problema SELECCIÓN s>=l: s::=s-l+1 Θ(1)
r::=Selección(A[l..j],s) TS ( j − l + 1)
ENDCASE
RETURN r Θ(1)

Análisis del tiempo de ejecución

Lema 2
I el algoritmo anterior genera la recurrencia: La posición r del resultado del algoritmo Pseudomediano(A)
3
cuando A tiene n elementos es tal que 10 n − 65 ≤ r ≤ 10
7
n + 65 .


 a si los elementos Prueba.
son iguales,



TS (n) = on≤5
Θ(n) + TS (bn/5c)+




+TS (maxk ,l (k − i + 1, j − l + 1)) sino

I ¿porqué? para saberlo es necesario conocer cómo se aproxima

el pseudomediano al mediano verdadero (ie la relación entre
k − i + 1 y j − l + 1 con n/2 .
Lema 3
La posición r del resultado del algoritmo Pseudomediano()
3 7
cuando A tiene n elementos es tal que 10 n − 4 ≤ r ≤ 10 n + 56 .
Prueba.
La mínima cantidad de elementos menores o iguales es
3
3d z2 e ≥ 10 n − 65 . Luego la máxima cantidad de elementos mayores es
3
menor que n − ( 10 n − 65 ) = 10
7
n + 65 . Por otro lado, la máxima
candidad de elementos menores es a lo sumo
2z + 3b z2 c + 4 ≤ 10 7
n + 4.

I la recurrencia para SELECCIÓN queda entonces

 Teorema 4

 a si los elementos TS (n) ∈ Θ(n)
son iguales, o n ≤ 5

TS (n) ≤ Prueba.
 Θ(n) + TS (bn/5c)+
Es fácil ver que TS (n) ∈ Ω(n). Para el orden, por inducción

maxm≤7n/10+4 (TS (m)) sino

constructiva sobre n, se encuentran los valores para c y n0 tales que
I no se puede analizar ni con el teorema maestro ni con la TS (n) ≤ cn para todo n ≥ n0 .
ecuación característica.
Quicksort revisado Quicksort revisado
Quicksort revisado
costo
Quicksort(A[i..j])
IF j-i es pequeño Θ(1)
Inserción(A[i..j]) Θ(1)
I usando entonces este algoritmo para calcular el mediano, y el
ELSE
pivoteo de la bandera holandesa se puede obtener la siguiente
piv ::= Mediano(A[i..j]) Θ(n)
versión de quicksort
PivotearBH(A[i..j],piv,k,l) Θ(n)
Quicksort(A[i..k]) T (n/2) peor caso
Quicksort(A[l..j]) T (n/2) peor caso
ENDIF

Elemento mediano Multiplicación de matrices
Quicksort revisado
MULTIPLICACIÓN DE MATRICES
I el tiempo de ejecución es
I se tiene el problema de calcular el producto C de dos matrices

Θ(1) si n es pequeño A, B cuadradas de dimensión n
T (n) =
2T (n/2) + Θ(n) sino I el algoritmo directo tiene tiempo de ejecución en Θ(n3 ), ya que
cada uno de los n2 elementos de C lleva tiempo Θ(n) en
I usando el teorema maestro, T (n) ∈ Θ(n log n).
computarse
I ¿qué pasa si esta versión de quicksort en lugar de llamar a I si existiera un algoritmo dividir y conquistar que partiera las
Mediano(), busca el pivote con PseudoMediano()? matrices originales en matrices de n/2 × n/2, 8 o más
(ejercicio)
multiplicaciones de estas matrices igualaría o empeoraría el
tiempo del algoritmo directo (ejercicio).
Multiplicación de matrices Multiplicación de matrices
Algoritmo de Strassen
I Strassen, a fines de los ’60s, descubrió que 7 productos son

suficientes
I la idea del algoritmo de Strassen es dividir las matrices en cuatro
partes iguales, y resolver el producto original en base a
operaciones sobre estas partes
I usando sumas y restas entre los componentes de Θ(n2 ), en
forma análoga al problema de multiplicar enteros grandes I cada una de A11 , . . . , C22 tiene dimensión n2 × n2 . Sumas y restas
de estas matrices se puede computar en tiempo Θ(n2 )

Multiplicación de matrices Multiplicación de matrices
n
I si se definen las siguientes matrices auxiliares, también de 2
× n2
M1 = (A21 + A22 − A11 ) × (B22 − B12 + B11 )

I el algoritmo de Strassen tiene tiempo de ejecución
M2 = A11 × B11
Θ(n3 )

M3 = A12 × B21 si n es pequeño
T (n) = 2
7T (n/2) + Θ(n ) sino
M4 = (A11 − A21 ) × (B22 − B12 )
M5 = (A21 + A22 ) × (B12 − B11 ) I resolviendo esta recurrencia con el teorema maestro resulta
T (n) ∈ Θ(nlog 7 ) (ejercicio) si el tamaño n de la matriz es
M6 = (A12 − A21 + A11 − A22 ) × B22
potencia de 2
M7 = A22 × (B11 + B22 − B12 − B21 )
I dado que log2 7 = 2,81 < 3 este algoritmo DYC es
I resulta que asintóticamente mejor que el algoritmo directo

C11 = M2 + M3 C12 = M1 + M2 + M5 + M6
C=
C21 = M1 + M2 + M4 − M7 C22 = M1 + M2 + M4 + M5
Multiplicación de matrices Par de puntos más cercanos
Definición del problema
I sea un conjunto de n
I para las matrices cuyos n no son potencia de 2, es necesario puntos en el plano (que
completarlas con 0’s hasta llegar a una potencia de 2 supondremos en el primer
I otros algoritmos similares se han definido siguiendo esta cuadrante). Problema: se
estrategia; se divide a la matriz en b × b partes, y se busca una quiere encontrar el par de
forma de calcular el producto con k componentes generados a puntos más cercanos.
partir de operaciones escalares en las partes tal que el algoritmo
I
directo
debe
logb k < log2 7. n
comparar pares de
2
puntos, por lo que su
tiempo está en Θ(n2 ).

Par de puntos más cercanos Par de puntos más cercanos
I para aplicar DYC se divide I el par de puntos buscado

el conjunto de puntos en puede estar repartido entre
partes iguales, por medio las dos mitades, por lo que
de una recta m, según el ni d1 ni d2 necesariamente
eje x. son solución
I se encuentran entonces d1 I entonces se crea Franja de
y d2 las distancias mínimas ancho 2d alrededor de la
en cada parte recta m, siendo
I pero la solución al d = min(d1 , d2 ), y se
problema original no se busca si existe una
encuentra tan fácil a partir distancia menor que d en
de estos dos valores esa zona
costo
I si existe en Franja una function MasCercanos(P[1..n])
distancia d3 < d entonces IF n es pequeño Θ(1)
ésa es la solución. En caso RETURN algoritmoBasico(P) Θ(1)
contrario la solución es d ELSE
I para que el algoritmo DYC m ::= punto medio de coord. x Θ(1)
sea más eficiente que el crear P1 y P2 ??
algoritmo directo, debe d1 ::= MásCercanos(P1) T (bn/2c)
tenerse cuidado que la d2 ::= MásCercanos(P2) T (dn/2e)
sobrecarga de la partición d ::= min(d1, d2) Θ(1)
y combinación sean de crear Franja con ancho 2d de m ??
tiempo menor que Θ(n2 ) d3 ::= recorrido(Franja) ??
RETURN min(d,d3)
ENDIF

Implementación Análisis del tiempo de ejecución
I para la creación eficiente de las subinstancias es posible ordenar

el arreglo P por coordenadas x una sola vez al comienzo de la
I luego se genera la recurrencia:
ejecución, agregando tiempo en Θ(n log n) por única vez
I para la creación de Franja y la búsqueda eficiente en ese

Θ(1) para n pequeño
arreglo se puede: T (n ) =
T (bn/2c) + T (dn/2e) + Θ(n log n) sino
I ordenar el arreglo P también por coordenada y
I partirlo de acuerdo a si cada punto pertenece o no a Franja I resolviendo cambio de variables y la regla de funciones de
I por cada punto considerar la distancia con solo los 7 siguientes crecimiento suave, resulta T (n) ∈ Θ(n log2 n).
dentro de Franja (esto es suficiente no puede haber más de 8
puntos en un rectángulo de 2d × d cuya distancia sea menor o
igual a d)
Par de puntos más cercanos Criptografía – exponenciación modular
Criptografía tradicional
Criptografía
2
I se puede mejorar el tiempo de Θ(n log n) a costa de incorporar
Esquema para protocolos de Clave Secreta
como entrada al algoritmo no solo P ordenado por coordenadas
x, sino también ordenado por coordenas y .
I de esta forma se elimina el ordenamiento en cada llamada
recursiva, realizándose solamente un única vez al comienzo del
algoritmo, y la creación de Franja se puede hacer entonces en
tiempo lineal
I el problema ahora es crear los nuevos arreglos ordenados por y
para cada llamada recursiva; pero esto puede hacerse en tiempo
lineal a partir del arreglo completo ordenado por y
I la recurrencia queda entonces T (n) = 2T (n/2) + Θ(n) que
sabemos que está en Θ(n log n)

Criptografía – exponenciación modular Criptografía – exponenciación modular
Criptografía tradicional Criptografía tradicional
Esquema de un protocolo de Clave Pública
I los protocolos de Clave Pública solo fueron posibles a partir del

estudio sistemático de la Algoritmia, a mediados de los ’70s
I a continuación se presentará una solución simple propuesta por
Rivest, Shamir y Adleman conocida como el sistema criptográfico
RSA (1978)
Protocolo RSA Protocolo RSA
Protocolo RSA
I B (el receptor del mensaje) elige dos números primos p y q I B también debe elegir un número n aleatorio, tal que
(cuanto más grandes, más difícil de quebrar el cifrado) y calcula 1 < n < z − 1, que no tenga factores comunes con (p − 1)(q − 1)
z = pq I existe un algoritmo eficiente (basado en el algoritmo de Euclides)
I existen algoritmos eficientes para testear si un número es primo que dado cualquier n, no sólo comprueba si cumple con la
(se verá más adelante un algoritmo probabilístico) y para propiedad sino que al mismo tiemo calcula el único s tal que
multiplicar enteros grandes (ya visto) 1 ≤ s ≤ z − 1 y ns mod (p − 1)(q − 1) = 1
I sin embargo, no se conocen algoritmos eficientes para factorear
z.

Protocolo RSA Protocolo RSA
I cuando B recibe c, a partir de la clave secreta s se calcula:

I lo interesante de estos números es que se puede probar que si
1 ≤ a < z entonces ax mod z = a, para todo x tal que c s mod z = (mn mod z )s mod z = (mn )s mod z = mns mod z = m
x mod (p − 1)(q − 1) = 1
I la clave pública está formada por z y n, y la clave secreta (sólo según la propiedad anterior
conocida por B) por s I es necesario una implementación eficiente de la exponenciación
I el remitente A del mensaje m, 1 ≤ m ≤ z − 1 (si no cumple con modular x y mod z
esta restricción, se parte el mensaje en pedazos de ese tamaño) I el espía, con conocimiento de c, n y z, sólo puede factorear z en
debe calcular c = mn mod z pq para hallar s y calcular m. Se supone que el factoreo de
números grandes no se puede realizar en tiempo razonable
Protocolo RSA Exponenciación modular
Exponenciación modular
Esquema de un protocolo de Clave Pública
I Problema: dados enteros grandes m, n, z se quiere calcular

mn mod z.
I la solución se obtiene a partir de un algoritmo DYC para calcular
exponentes de enteros grandes
I usando además las siguientes propiedades:
x y mod z = (x mod z )y mod z
xy mod z = [(x mod z )(y mod z )] mod z

Exponenciación modular Exponenciación modular
I el algoritmo DYC resulta

I si y es par, y = 2y 0 luego function Expomod(x,y,z)
0 0 a ::= x mod z
x y mod z = x 2y mod z = (x 2 mod z )y mod z IF y=1
I si y > 1 es impar, y = 2y 0 + 1 luego
RETURN a
ELSEIF y es par
0 0
x y mod z = x 2y +1 mod z = x 2y x mod z = aux ::= a^2 mod z
0
= [(x 2y mod z )(x mod z )] mod z RETURN Expomod(aux,y/2,z)
ELSEIF y es impar
RETURN (a * Expomod(a,y-1,z)) mod z
I como la instancia se resuelve en base a la solución de un sólo ENDIF
subproblema, se trata de un caso de simplificación
Exponenciación modular Exponenciación modular
Análisis del tiempo de ejecución

I para solucionar la recurrencia se expande una vez el caso impar:
TEXP (y ) = TEXP (y − 1) + Θ(|z |2 ) =

= TEXP (by /2c) + Θ(|z |2 ) + Θ(|z |2 ) =
I La recurrencia de su tiempo de ejecución es: = TEXP (by /2c) + Θ(|z |2 )

 Θ(|x | + |z |) si y = 1 I con lo que:
2
TEXP (y ) = TEXP (y /2) + Θ(|z | ) si y es par
TEXP (y − 1) + Θ(|z |2 ) si y es impar

Θ(|x | + |z |) si y = 1
TEXP (y ) ≤ 2
I ni siquiera es eventualmente no decreciente TEXP (by /2c) + Θ(|z | ) si y > 1
I esta nueva recurrencia, que sí es eventualmente no decreciente,

tiene como resultado TEXP (y ) ∈ O (log y ), considerando
constante el costo de las multiplicaciones

Criptografía – exponenciación modular Transformada Rápida de Fourier (FFT)
Exponenciación modular
Transformada de Fourier
I análogamente se muestra que TEXP (y ) ∈ Ω(log y )

I tener en cuenta para ambos casos que y es el valor de uno de
los datos de entrada, y no su longitud
I este tiempo asintótico se puede mejorar usando el algoritmo DYC
para multiplicación de enteros grandes
I esta algoritmo es el algoritmo de encriptación y decriptación del
protocolo RSA.
I la Transformada de Fourier toma una función representando un

patrón basado en tiempo y la descompone en función de varios
ciclos
Transformada Rápida de Fourier (FFT) Transformada Rápida de Fourier (FFT)
Transformada de Fourier Polinomios: representación por coeficientes
I tiene muchas aplicaciones:

I técnicas de codificación de video y audio digital(MP3, JPEG, I sea A(x ) un polinomio, se puede representar por coeficientes
MPEG)
como A(x ) = a0 + a1 x + a2 x 2 + . . . + an−1 x n−1 de grado n − 1,
I ecualización de audio
I filtros de imágenes (Gaussian blur) siendo los coeficientes ai ∈ F y F un campo cualquiera (por
I procesamiento de señales de sonar para clasificar objetivos ejemplo Q, R, C, . . .)
I vibraciones de terremotos I alternativamente A(x ) = ∑nk =0 ak x k , o A(x ) = ha0 , a1 , . . . , ak i
I etc
I se dice que A(x ) está grado-acotado por n si su grado es
I la señal original se representa como un polinomio de señales n − 1, n − 2, . . . , 0
más sencillas
I es necesario representar polinomios y computar sus operaciones

Polinomios: representación por raíces Polinomios: representación por muestras
I también se puede representar un polinomio A(x ) grado-acotado

por n tomando n muestras
I A(x ) se puede representar también por sus raíces
ri , 1 ≤ i ≤ n − 1, entonces A(x ) = c (x − r1 ) . . . (x − rn−1 )
A(x ) = {((x0 , y0 ), (x1 , y1 ), . . . , (xn−1 , yn−1 )}
I se garantiza que está representación es única
siempre que los xk sean todos distintos y que A(xk ) = yk
Teorema 5 (Teorema fundamental del algebra)
Todo polinomio de grado n − 1 con ai ∈ C tiene exactamente n − 1 Teorema 6 (Unicidad de la representación por muestras)
raíces complejas, contando multiplicidades. Para cualquier conjunto {(x0 , y0 ), (x1 , y1 ), . . . , (xn−1 , yn−1 )} de n
muestras tal que todos los xk son distintos, existe un único polinomio
A(x ) grado-acotado por n tal que A(xk ) = yk para todo i , 1 ≤ i ≤ n.
Operaciones con polinomios Cálculo con coeficientes
I evaluación: A(x0 ) = ∑nk −1 k 2

=0 ak x0 con tiempo en O (n )
I pero con la regla de Horner
A(x0 ) = a0 + x0 (a1 + x0 (a2 + . . . x0 (an−2 + x0 (an−1 )) . . .)) con
I evaluación dados A(x ) y x0 , encontrar y0 = A(x0 ) tiempo en O (n) (usando simplificación=DYC con una sola
I suma dados A(x ) y B (x ), encontrar C (x ) = A(x ) + B (x ) subinstancia)
I multiplicación dados A(x ) y B (x ), encontrar C (x ) = A(x ) × B (x ) I suma: dados A(x ) = ∑nk =0 ak xk y B (x ) = ∑nk =0 bk xk entonces
I convolución dados A(x ) y B (x ), encontrar C (x ) = A(x ) ⊗ B (x ) C (x ) = ∑nk =0 (ak + bk )xk con tiempo O (n)
I multiplicación: dados A(x ) = ∑nk − 1 n−1
=0 ak xk y B (x ) = ∑k =0 bk xk
−2
entonces C (x ) = ∑2n k k
k =0 (∑j =0 aj bk −j )x con tiempo O (n )
2
I convolución: coincide con la multiplicación, interpretando los

polinomios como vectores

Cálculo con raíces Cálculo con muestras
I evaluación: es necesario calcular la intrepolación de polinomios

para obtener A(x0 ) cuyo tiempo es O (n2 )
I suma: dados A(x ) = {(xi , yiA ), 0 ≤ i ≤ n − 1} y
I evaluación: A(x0 ) = c ∑nk −1
=0 (x0 − rk ) con tiempo en O (n) B (x ) = {(xi , yiB ), 0 ≤ i ≤ n − 1} representados por muestras
I suma: no es posible sobre los mismos puntos xi , entonces
I multiplicación: dados A(x ) = c A ∑nk =0 (x − rkA ) y C (x ) = A(x ) + B (x ) = {(xi , yiA + yiB ), 0 ≤ i ≤ n − 1} con tiempo
B (x ) = c B ∑nk =0 (x − rkB ) entonces O (n )
C (x ) = c A c B ∏kn− 1 A B
=0 (x − rk )(x − rk ) con tiempo O (n) I multiplicación: dados A(x ) = {(xi , yiA ), 0 ≤ i ≤ n − 1} y
B (x ) = {(xi , yiB ), 0 ≤ i ≤ n − 1} representados por muestras
sobre los mismos puntos xi , entonces
C (x ) = A(x ) × B (x ) = {(xi , yiA + yiB ), 0 ≤ i ≤ n − 1} con tiempo
O (n )
Transformaciones: coeficientes a muestras Transformaciones: muestras a coeficientes
I sean xi , 0 ≤ i ≤ n − 1 los puntos donde se quiere muestrear el

polinomio, entonces los valores yi , 0 ≤ i ≤ n − 1 se obtienen
resolviendo VA = Y donde I dada la representación por muestras
A(x ) = {(xi , yiA ), 0 ≤ i ≤ n − 1}, se puede resolver VA = Y para
hallar A usando eliminación de Gauss, en tiempo de O (n3 )
. . . x0n−1

x02
   
1 x0 a0 y0
I alternativamente, se puede hallar Vn−1 la matriz inversa de
 1 x1 x12 . . . x1n−1   a1   y1 

 .. .. .. ..

..   .. =
 
..

 Vandermonde, y calcular A = V −1 Y en tiempo O (n2 )
. . . . .  . .
V −1 se puede hallar en tiempo de O (n2 ) usando la fórmula de
   
I
n−1
1 xn−1 xn2−1 . . . xn−1 an−1 yn−1
Lagrange (ejercicio)
I usando la regla de Horner se puede resolver en tiempo de O (n2 )
I Vn tal que [Vn ]jk = xjk se denomina la matriz de Vandermonde

Transformaciones a y desde representación por raíces Resumen
Coeficientes Raíces Muestras

I si tenemos los polinomios representados por coeficientes o evaluación O (n ) O (n) O (n2 )
muestras, sólo se pueden obtener algebraicamente la raíces de suma O (n ) – O (n)
polinomios grado-acotados por 5 producto O (n2 ) O (n) O (n)
I se pueden obtener las muestras a partir de las raíces hacien n
evaluaciones (de tiempo O (n)) I FFT permitirá la transformación Coeficientes↔Muestras en
tiempo O (n log n), y acotar así también los tiempos de las
operaciones no importa su representación
Algoritmo DYC para la transformación Algoritmo DYC para la transformación
costo
Recursiv-Transf(A,X)
Θ(1)
I el tiempo de ejecución es, si |A| = n y |X | = m,
IF (A.length=1) RETURN A
X^2 ::= {X[i]*X[i], 0<= i<= m-1} Θ(m)
Θ(1) si n = 1
Apar ::= {A[0], A[2],..., A[n-2]} Θ(n) TRT (n, m) =
2TRT (n/2, m) + Θ(n + m) si n > 1
Aimpar ::= {A[1],A[2],...,A[n-1]} Θ(n)
Ypar ::= Recursiv_Transf( Apar,X^2) I por inducción constructiva TRT (n, m) ∈ O (nm)
Yimpar ::= Recursiv_Transf(Aimpar,X^2) I como n = m al inicio, entonces es O (n2 ), no es suficiente
Y ::= {Ypar[i]+
X[i]*Yimpar[i], 0<= i <= m-1} Θ(m)
RETURN Y

Tiempo de ejecución Conjuntos colapsantes
I X es colapsante si |X 2 | = |X |/2 y X 2 también es colapsante

I como caso base sirve cualquier singleton cuyo elemento no sea
I sería necesario que el tamaño de los puntos de muestras X 0. Podría ser X = {1}
disminuya al mismo tiempo que los coeficientes A
I se tiene la ventaja de que los puntos de muestras son arbitrarios |X | = 1 X = { 1}
|X | = 2 X = {1, −1}
|X | = 4 X = {1, −1, i ,√
−i }
|X | = 8 X = {±1, ±i , 2/2(±1 ± i )}
...
Raíces enésimas de la unidad Raíces enésimas de la unidad: propiedades

j jn
I el conjunto Xn = {ωn : ω ∈ C ∧ ωn = 1} de raíces enésimas de
Lema 7 (Lema de Cancelación)
la unidad para n = 2k es un conjunto colapsante
dk
ωdn = ωnk para n ≥ 0, k ≥ 0, d > 0.
I |X | = n con ωnj = e2π j /n , 0 ≤ j ≤ n − 1 o lo que equivale
ωnj = cos(2π j /n) + i sin(2π j /n) Lema 8
I los ω también se llaman números de De Moivre Si n > 0 es par, entonces los cuadrados de las raíces n-esimas de la
unidad son las n/2 raíces n/2-esimas de la unidad.
Lema 9
∑nj =−01 (ωkn )j = 0 para n ≥ 1, k 6= 0 y k no divisible por n
I las demostraciones quedan como ejercicios
I las raíces enésimas de la unidad forman un grupo (asociativa,
elemento neutro y elemento simétrico) con la multiplicación, con
propiedades similares a (Z, +mod n )

Transformada Rápida de Fourier Algoritmo eficiente para FFT

I FFT (A) = Recursiv _Transf (A, Xn ) donde Xn son las raíces
enésimas de la unidad FFT(A)
n::= A.length
I entonces, n = m y vale
IF (n=1) RETURN A
TFFT (n) = 2TFFT (n/2) + Θ(n) ∈ Θ(n log n)
wn ::= e^2*PI*i/n; w ::= 1
I de esta manera podemo realizar cualquier operación sobre Apar ::= {A[0],A[2],...,A[n-2]}
polinomios en tiempo Θ(n log n), usando las implementaciones Aimpar ::= {A[1],A[3],...,A[n-1]}
más eficientes posiblemente combinadas con transformaciones Ypar ::= Recursiv_Transf(Apar)
I para que esto sea cierto necesitamos la transformada inversa a Yimpar ::= Recursiv_Transf(Aimpar)
la FFT, de muestras a coeficientes FOR k::=0 TO n/2-1
I la transformada discreta de Fourier (DFT) es la evaluación de un Y[k] ::= Ypar[k]+w*Yimpar[k]
polinomio A en los puntos Xn determinados por las raíces Y[k+n/2] ::= Ypar[k]-w*Y[Yimpar[k]
enésimas de la unidad w ::= w*wn
RETURN Y
en DFT (A) = {yk = ωnk } = {∑nj =−01 aj ωn }
kj
I
Transformada inversa Convolución de dos vectores
I permite ir de la representación por muestras a la de coeficientes

Lema 11 (Teorema de convolución)
Lema 10 Sean a, b dos vectores de longitud n = 2k entonces
Vn−1 = V¯n /n
a ⊗ b = IFFT2n (FFT2n (a) · FFT2n (b))
Demostración.
−mj k (j −k )
Se calcula [Vn−1 Vn ]jk = ∑nm−=10 (ωn /n)(ωnmk ) = ∑nm−=10 ωn /n. donde los vectores a, b se completan con 0s hasta la longitud 2n, y ·
I entonces IFFT (Y ) = Recursiv _Transf (Y , X¯n /n), y también es en representa la multiplicación componente a componente.
Θ(n log n)

DividirYConquistar 4x1

Cargado por

Copyright:

Formatos disponibles

DividirYConquistar 4x1

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

DividirYConquistar 4x1

Cargado por

Copyright:

Formatos disponibles

Algoritmos y Complejidad Algoritmos y Complejidad

Algoritmos “dividir y conquistar”

Transformada Rápida de Fourier (FFT)

Algoritmos y Complejidad Algoritmos y Complejidad

Algoritmos y Complejidad Algoritmos y Complejidad

Análisis general del tiempo de ejecución

Determinación del umbral

I la determinación del umbral no afecta en general el orden del

suponiendo el algoritmo directo de Θ(n2 )

Algoritmos y Complejidad Algoritmos y Complejidad

MULTIPLICACION DE ENTEROS GRANDES

Algoritmos y Complejidad Algoritmos y Complejidad

I se puede reducir esta cantidad de productos, observando

r = (x + y)(w + z) = I si el tiempo del algoritmo directo es an2 + bn + c y el de la

(xz + yw) = r − xw − yz T (n ) = 3a(bn/2c)2 + 3bbn/2c + 3c + g (n)

Algoritmos y Complejidad Algoritmos y Complejidad

I si m 6= n pero ambos son de la misma magnitud, entonces es

Algoritmos y Complejidad Algoritmos y Complejidad

I un algoritmo naïve para resolver BÚSQUEDA BINARIA es:

Algoritmos y Complejidad Algoritmos y Complejidad

Análisis del tiempo de ejecución Mergesort

I sea m = j − i + 1. El tiempo de ejecución genera la recurrencia:

Algoritmos y Complejidad Algoritmos y Complejidad

I informalmente, el tiempo de ejecución está determinado por la

que resulta T (n) ∈ Θ(n2 ).

Algoritmos y Complejidad Algoritmos y Complejidad

I a diferencia de mergesort, que hace una descomposición trivial costo

Primera parte: encontrar los dos primeros elementos para

Algoritmos y Complejidad Algoritmos y Complejidad

Segunda parte: si existen esos elementos, intercambiarlos y encontrar

Algoritmos y Complejidad Algoritmos y Complejidad

I con el objetivo de mejorar el tiempo de ejecución en el peor caso

Algoritmo de pivoteo de la bandera holandesa

Algoritmos y Complejidad Algoritmos y Complejidad

SELECCCIÓN ELEMENTO MEDIANO

I la solución obvia a este problema es ordenar el arreglo y devolver

Algoritmos y Complejidad Algoritmos y Complejidad

Reducciones Reducción SELECCIÓN −→ MEDIANO

I a partir de este algoritmo, cambiando la elección del pivote, se

Algoritmos y Complejidad Algoritmos y Complejidad

Algoritmos y Complejidad Algoritmos y Complejidad

Análisis del tiempo de ejecución

I ¿porqué? para saberlo es necesario conocer cómo se aproxima

Algoritmos y Complejidad Algoritmos y Complejidad

I la recurrencia para SELECCIÓN queda entonces

Algoritmos y Complejidad Algoritmos y Complejidad

I Strassen, a fines de los ’60s, descubrió que 7 productos son

Algoritmos y Complejidad Algoritmos y Complejidad

M1 = (A21 + A22 − A11 ) × (B22 − B12 + B11 )

Definición del problema

Algoritmos y Complejidad Algoritmos y Complejidad

I para aplicar DYC se divide I el par de puntos buscado

Algoritmos y Complejidad Algoritmos y Complejidad

Implementación Análisis del tiempo de ejecución

I para la creación eficiente de las subinstancias es posible ordenar

Algoritmos y Complejidad Algoritmos y Complejidad

Esquema de un protocolo de Clave Pública

I los protocolos de Clave Pública solo fueron posibles a partir del

Algoritmos y Complejidad Algoritmos y Complejidad