algoritmos “dividir y conquistar”algoritmos y complejidad algoritmos “dividir y conquistar”...

IntroducciónOrdenamiento: mergesort y quicksort

Elemento medianoMultiplicación de matrices

Par de puntos más cercanosCriptografía – exponenciación modular

Algoritmos y ComplejidadAlgoritmos “dividir y conquistar”

Pablo R. Fillottrani

Depto. Ciencias e Ingeniería de la ComputaciónUniversidad Nacional del Sur

Primer Cuatrimestre 2011

Pablo R. Fillottrani Algoritmos y Complejidad




Algoritmos “dividir y conquistar”

1 Introducción

2 Ordenamiento: mergesort y quicksort

3 Elemento mediano

4 Multiplicación de matrices

5 Par de puntos más cercanos

6 Criptografía – exponenciación modular





GeneralidadesMultiplicación de enteros grandesBúsqueda binaria

Generalidades

“dividir y conquistar” (DYC) es un técnica de diseño de algoritmosque consiste en

1 descomponer la instancia del problema a resolver en un conjuntode instancias más pequeñas del mismo problema

2 resolver independientemente cada una de estas subinstancias3 combinar estas soluciones en una solución a la instancia original.

es probable que esta técnica resulte en un algoritmo máseficiente que el original.






es importante entonces determinar para cada problema:1 cuáles son las subinstancias, y cómo se encuentran2 cómo solucionar el problema en las subinstancias3 cómo combinar las soluciones parciales

para el punto 2. se puede aplicar nuevamente la técnica DYC,hasta que se llegue a subinstancias de tamaño suficientementepequeño para ser resueltas inmediatamente.






Esquema General

function DYC(x)IF x es suficientemente simple

RETURN algoritmoBasico(x)ELSE

descomponer x en x[1],x[2],...,x[s]FOR i ::= 1 TO s

y[i] ::= DYC(x[i])ENDFORcombinar y[i] en una solución y a xRETURN y

ENDINF






se debe especificar cuáles son el algoritmo básico, el dedescomposición y el de combinación.

también se necesita determinar cuándo una instancia essuficientemente simple como para dejar de aplicar la división.

si se trata de tamaño, este valor se denomina umbral.






Análisis general del tiempo de ejecución

el tiempo de ejecución está determinado por la recurrencia:

TDYC(n) =

⇢f (n) si n es simplesTDYC(n÷b)+g(n) sino

donden = |x |b es una constante tal que n÷b aproxime el tamaño de lassubinstanciasf (n) es el tiempo de algoritmoBásico()g(n) es el tiempo de la partición y combinación.






los métodos vistos para resolver recurrencias brindan solucionesa la mayoría de las recurrencias generadas por algoritmos DYC.

en especial el método del teorema maestro.

para que DYC sea eficiente las subinstancias deben ser todas deaproximadamente el mismo tamaño.

además, se debe estudiar cuidadosamente cuál o cuáles son losmejores umbrales.






Determinación del umbral

la determinación del umbral no afecta en general el orden deltiempo de ejecución de los algoritmos DYC

pero sí afecta considerablemente las constantes ocultas

ejemplo

TDyC =

⇢n2 µseg si n n0

3TDyC(bn/2c)+16n µseg sino

suponiendo el algoritmo directo de ⇥(n2)

entonces resulta TDYC(n) 2⇥(nlog3)






cambiando el umbral se obtienen los siguientes tiemposabsolutos:

n TDyC con n0 = 1 TDyC con n0 = 64 Algoritmo básico5000 41 seg 6 seg 25 seg32000 15 min 2min 15 min






es muy difícil, o a veces imposible, encontrar teóricamente unumbral optimal (ya sea para cada instancia o incluso para cadan).

puede pasar que el umbral óptimo cambia de instancia eninstancia, y que dependa de cada implementación en particular.

también es poco práctico encontrar empíricamente unaaproximación a un buen umbral: sería necesario ejecutar elalgoritmo muchas veces en una gran cantidad de instanciasla solución generalmente tomada es un camino híbrido:

1 se encuentra la función exacta del tiempo de ejecución de losalgoritmos (no alcanza con conocer sólo el orden!) dando valoresa las constantes de acuerdo pruebas empíricas.

2 se toma como n0 un valor en el cual tome aproximadamente elmismo tiempo el algoritmo directo que el DyC






Correctitud

a diferencia de los algoritmos greedy, es fácil probar lacorrectitud de los algoritmo DYC

se supone la correctitud del algoritmo básico, y se prueba porinducción sobre el tamaño de la instancia que la soluciónobtenida es correcta suponiendo la correctitud de las instanciasmás chicas

no vamos a ver en detalle ninguna prueba de correctitud paraDYC, pero no son difíciles de hacer






MULTIPLICACION DE ENTEROS GRANDES

Problema: supongamos que tenemos que multiplicar dos enterosa y b, de n y m dígitos cada uno, cantidades que no son posiblesde representar directamente por el HW de la máquinaes fácil implementar una estructura de datos para estos enterosgrandes, que soporte

1 suma de ⇥(n+m).2 resta de de ⇥(n+m).3 productos y divisiones por la base de ⇥(n+m).






si se implementa cualquiera de los algoritmos tradicionales parael producto entre dos números cualesquiera, el resultado es de⇥(nm)

aplicaremos DYC para tratar de mejorar este tiempo. Suponiendopor el momento que n = m






aplicando DYC una sola vez, y usando base 10 se tiene:a x y b w z

dn/2e bn/2c dn/2e bn/2cesto es:

a⇥b = (x10bn/2c+y)⇥ (w10bn/2c+ z) =

= xw102bn/2c+(xz+wy)10bn/2c+yz






si se extiende el método aplicando DYC recursivamente seobtiene la recurrencia:

tDyC(n) =

⇢⇥(n2) si n n0

4tDyC(dn/2d)+⇥(n) sino

el resultado no es bueno (aplicar el teorema maestro!)

el principal problema es que se necesitan cuatro productos máspequeños.






se puede reducir esta cantidad de productos, observando

r = (x+y)(w+ z) =

= xw+(xz+yw)+yz

con lo que resulta

(xz+yw) = r�xw�yz

y también

a⇥b = xw102bn/2c+(r�xw�yz)10bn/2c+yz

se tiene entonces dos productos de bn/2c dígitos, un productode a lo sumo bn/2c+1 dígitos, más sumas, restas y productosde potencias de la base.






si el tiempo del algoritmo directo es an2 +bn+ c y el de lasobrecarga es g(n), entonces aplicando DYC una sóla vez seobtiene

T (n) = 3a(bn/2c)2 +3bbn/2c+3c+g(n)

(3/4)an2 +(3/2)bn+3c+g(n)

comparado con an2 +bn+ c es sólo una mejora del 25% en laconstante del término principal, pero igualmente es de ⇥(n2)






para obtener una mejora asintótica es preciso aplicar DYCrecursivamente a los productos más pequeños

el tiempo de este algoritmo genera la siguiente recurrencia:

TDyC(n) =

8<

:

⇥(n2) si n es pequeñoTDyC(bn/2c)+TDyC(dn/2e)++TDyC(bn/2c+1)+⇥(n) sino






se puede deducir de esta recurrencia queTDyC(n) 2 O(nlog3|n = 2k), usando otra vez el teorema maestro.

como TDyC(n) es eventualmente no decreciente y nlog3 es decrecimiento suave, entonces TDyC(n) 2 O(nlog3), aplicando laregla de las funciones de crecimiento suave.

análogamente se puede mostrar que TDyC(n) 2 ⌦(nlog3)(ejercicio).






restaría determinar cuál es el tamaño suficientemente pequeñopara que convenga aplicar el algoritmo directo. ¿Cómo podríahacerse?

usando el método híbrido, encontrando la intersección entre eltiempo DYC y el tiempo del algoritmo básico






si m 6= n pero ambos son de la misma magnitud, entonces esposible completar el número más chico con ceros hasta llegar altamaño del más grande

pero esta solución no siempre es buena.

¿cómo aprocechar mejor la misma técnica si m << n? (ejercicioAyuda: partir los números en pedazos de a m)

en este caso se puede obtener un resultado de ⇥(nmlog(3/2)),que es asintóticamente mejor que ⇥(nm), o que ⇥(nlog3) sim << n






BÚSQUEDA BINARIA

Problema: dado un arreglo de enteros T [1..n], ordenado enforma creciente, y un entero x , se quiere encontrar el índice i talque T [i �1]< x T [i]

por simplicidad se supone la convención de que T [0] =�• yT [n+1] = +•.

el tradicional algoritmo de búsqueda binaria puede verse comouna degeneración de algoritmos DyC, en donde la cantidad desubinstancia es 1

en estos casos la técnica DYC se denomina simplificación






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

function BúsquedaSecuencial(T[1..n],x)FOR i ::= 1 TO n

IF T[i]>=xRETURN i

ENDIFENDFORRETURN n+1






este algoritmo naïve tiene tiempo ⇥(n) en el peor caso, y ⇥(1)en el mejor caso

si todas las instancias del arreglo tienen igual probabilidad de serllamadas, entonces el tiempo promedio también es de ⇥(n)

para aplicar DYC se determina en cuál mitad del arreglo deberíaestar x , comparándolo con el elemento del medio

luego se busca recursivamente en esa mitad






function BúsqBinaria(T[i..j],x)IF i=j

RETURN iELSE

k ::= (i+j) div 2IF x<=T[k]

RETURN BúsqBinaria(T[i..k],x)ELSE

RETURN BúsqBinaria(T[k+1..n],x)ENDIF

ENDIF






Análisis del tiempo de ejecución

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

T (m)⇢

a si m = 1b+ t(dm/2e) sino

resolviendo se obtiene T (m) 2⇥(logm) en el peor caso

el mismo resultado se obtiene aún en el mejor caso. ¿cómo sepuede modificar el algoritmo para mejorar este punto?





MergesortQuicksort

Mergesort

mergesort es el algoritmo “obvio” para el ordenamiento de unarreglo usando DYC.

consiste en partir el arreglo en dos mitades, ordenar cada una delas mitades por separado y hacer una mezcla de estas mitadesya ordenadas.





MergesortQuicksort

Mergesort(A[1..n])IF n es pequeño

RETURN Inserción(A)ELSE

crear A1 y A2 subarreglos de AB1 ::= Mergesort(A1)B2 ::= Mergesort(A2)Mezcla(B1, B2, B)RETURN B

ENDIF





MergesortQuicksort

la partición consiste en la creación de dos mitades del arreglooriginal

la combinación es la mezcla de las mitades ordenadas

hay que tener cuidado con el manejo de los parámetros, paraevitar duplicar los arreglos. En este caso se pasarán los índices





MergesortQuicksort

informalmente, el tiempo de ejecución está determinado por larecurrencia:

T (n) =

⇢⇥(1) si n es pequeño2T (n÷2)+⇥(n) sino

donde:⇥(1) es el tiempo de Inserción(), que es ser acotado por unaconstante suficientemente grande porque vale cuando n espequeño⇥(n) es el tiempo de la partición y de la mezcla





MergesortQuicksort

según el método del teorema maestro, el resultado es deO(n logn), en el mismo orden que heapsort

para una demostración formal, habría que resolver la recurrenciaT (n) = T (bn/2c)+T (dn/2e)+⇥(n), que también da de⇥(n logn).





MergesortQuicksort

es fundamental para que el tiempo sea de ⇥(n logn) que las dossubinstancias en las que se parte el problema sean de tamañosemejante

en el caso extremo de partir en subinstancias de tamañodesparejo, la recurrencia sería

T (n) =

8<

:

⇥(n2) si n n0

T (n�1)+T (1)+⇥(n) == T (n�1)+⇥(n) sino

que resulta T (n) 2⇥(n2).





MergesortQuicksort

Ejercicios

¿qué pasa si se divide el problema original en subinstancias detamaño k y n� k , con k constante?

¿qué pasa si se divide el problema original en tres subinstanciasde tamaño semejante?

¿qué pasa si la partición o la combinación toman tiempo de⇥(n2) en lugar de ⇥(n)?





MergesortQuicksort

Quicksort

a diferencia de mergesort, que hace una descomposición trivialpero con una recombinación costosa, el algoritmo quicksort(Hoare) pone énfasis en la descomposición

la partición del arreglo a ordenar se realiza eligiendo un elemento(el pivote), y luego partiendo en dos subarreglos con loselementos menores o iguales al pivote, y con lo elementosmayores que el pivote.

estos nuevos arreglos son ordenados en forma recursiva, ydirectamente concatenados para obtener la solución al problemaoriginal.

es posible obtener una implementación del pivoteo en tiempo de⇥(n), incluso realizando una sola recorrida al arreglo





MergesortQuicksort

Quicksort(A[i..j])IF j-i es pequeño

Inserción(A[i..j])ELSE

piv ::= A[i]Pivotear(A[i..j],piv,l)

% intercambiar A[i] y A[l]Quicksort(A[i..l-1])Quicksort(A[l+1..j])

ENDIF

costo

c⇥(1)

c⇥(n)c

T (n�1) peor caso





MergesortQuicksort

el tiempo de ejecución es

T (n) =

⇢⇥(1) si n es pequeñoT (n�1)+⇥(n) sino

usando la ecuación característica, T (n) 2⇥(n2).





MergesortQuicksort

Algoritmo de pivoteo

Primera parte: encontrar los dos primeros elementos paraintercambiar

Pivotear(A[i..j],piv,var l)k ::= i; l ::= j+1REPEAT

k ::= k+1UNTIL A[k]>piv or k>jREPEAT

l ::= l-1UNTIL A[l]<=piv...





MergesortQuicksort

Segunda parte: si existen esos elementos, intercambiarlos y encontrarlos siguientes elementos para intercambiar

...WHILE k<l

intercambiar A[k] y A[l]REPEAT

k ::= k+1UNTIL A[k]>pivREPEAT

l ::= l-1UNTIL A[l]<=piv

ENDWHILE





MergesortQuicksort

el total de iteraciones es l � i +1 para k y j +1� l para j

luego en total de iteraciones es de ⇥(j � i)

como el tiempo del cuerpo de los ciclos es constante, el tiempototal es entonces de ⇥(j � i)





MergesortQuicksort

Análisis probabilístico

se puede probar que el tiempo promedio del quicksort es de⇥(n logn), asignando igual probabilidad a todos los arreglos

supongamos que todas las n! instancias tienen igual probabilidadde ser llamadas, y que todos los elementos de T son distintos

esto implica que el pivote cae con igual probabilidad en cada unade las posiciones del arreglo a ordenar; y también que cada unode las subinstancias generadas heredan una distribuciónuniforme.





MergesortQuicksort

el tiempo promedio está definido entonces por la recurrencia:

Tprom(n) =1n(

n�1

Âk=0

⇥(n)+Tprom(k)+Tprom(n�1� k)) =

= ⇥(n)+2n

n�1

Âk=0

Tprom(k) =

= ⇥(n)+2n[Tprom(0)+Tprom(1)+

n�1

Âk=2

Tprom(k)] =

= ⇥(n)+2n

n�1

Âk=2

Tprom(k)





MergesortQuicksort

Teorema

Quicksort tiene tiempo promedio en O(n logn).

Prueba.Por inducción constructiva se encuentran los valores para c tal queTprom(n) cn logn.





MergesortQuicksort

con el objetivo de mejorar el tiempo de ejecución en el peor casode quicksort para llevarlo a ⇥(n logn) se podría implementar unamejor elección del pivote

se podría elegir cómo pivote el elemento mediano (aquel queestaría en la posición del medio una vez ordenado el arreglo),que parte al arreglo en dos mitades semejantes.

pero esto no siempre es así si el arreglo tiene elementosrepetidos.

luego se necesita además partir el arreglo en tres partes(menores, iguales y mayores), no sólo en dos





MergesortQuicksort

en resumen, para que quicksort sea de tiempo ⇥(n logn) en elpeor caso se requiere:

una mejor elección del pivote, que asegure subarreglos detamaño semejante, pero siempre en tiempo ⇥(n).modificar el pivotear para partir el arreglo en tres subarreglos: loselementos menores, los elementos iguales y los elementosmayores que el pivote.

estas “mejoras” involucran constantes ocultas que hacen delalgoritmo resultante practicamente inviable comparado con laversión naïve.

se verá a continuación primero el nuevo algoritmo de pivoteo, yluego cómo mejorar la elección del pivote.





MergesortQuicksort

Algoritmo de pivoteo de la bandera holandesa

function PivoteoBH(p,var T[i..j],k,l)k ::= i-1; m ::= i; l ::= j+1WHILE m<l

CASET[m]=p: m ::= m+1T[m]>p: l ::= l-1; swap(T[m],T[l])T[m]<p: k ::= k+1; swap(T[m],T[k])

m ::= m+1ENDCASE

ENDWHILE

el tiempo es de ⇥(n); es más, sólo recorre al arreglo una vez(ejercicio).





MergesortQuicksort

también se puede elegir el pivote al azar, resultando en unaversión probabilística de Quicksort con tiempo esperado de⇥(n logn)

la ventaja de esta versión es que no existe una instancia en laque tarde más, sino que ciertas ejecuciones sobre cualquierinstancia son las que llevan el peor caso





SelecciónQuicksort revisado

SELECCCIÓN ELEMENTO MEDIANO

Problema: se tiene un arreglo A[1..n] de enteros, nonecesariamente ordenado, y se quiere encontrar el elementomediano.

éste es el elemento que estaría en la posición dn/2e si el arregloestuviera ordenado.

si el elemento mediano es elegido como pivote cuando no hayelementos repetidos, se asegura la partición del arreglo ensubarreglos de tamaño semejante






la solución obvia a este problema es ordenar el arreglo y devolverA(dn/2e)pero su tiempo de ejecución es de ⇥(n logn), y eso no mejoraríaquicksort (ejercicio)

para mejorar asintóticamente este tiempo, se solucionará unproblema más general, denominado SELECCIÓN.






SELECCIÓN

Problema: se tiene un arreglo A[1..n] de enteros, nonecesariamente ordenado, y un entero s,1 s n. Se quiereencontrar el elemento s-ésimo.

el s-esimo elemento es el elemento que estaría en la posición sde estar el arreglo ordenado

SELECCIÓN y MEDIANO son equivalentes (existen reduccionesen ambas direcciones).






Reducciones

la reducción MEDIANO �! SELECCIÓN es trivial, basta conllamar a SELECCIÓN con s = dn/2e.

la reducción SELECCIÓN �! MEDIANO tampoco es difícil, yaque es muy parecida al algoritmo de búsqueda binaria






Reducción SELECCIÓN �! MEDIANO

function Selección(A[i..j],s)p ::= Mediano(A[i..j])PivotearBH(p,A[i..j],k,l)CASE

s<=k: j ::= kr ::= Selección(T[i..j],s)

k<s<l: r ::= ps>=l: i ::= l

r ::= Selección(T[i..j],s-l+1)ENDCASERETURN r






la cantidad de llamadas recursivas es de ⇥(logn), similar a labúsqueda binaria

se puede transformar en un algoritmo iterativo sin problemas.






a partir de este algoritmo, cambiando la elección del pivote, sepuede asegurar un peor tiempo lineal para SELECCIÓN

el pivote no necesariamente es exactamente el mediano.

esta solución también servirá para nuestro problema original:MEDIANO






se necesita entonces un algoritmo eficiente para seleccionar unelemento que divida al arreglo ordenado en partes“suficientemente” parejas.

Ejercicio: Sea TS(n) el tiempo del algoritmo de SELECCIÓN.Supongamos que seleccionar el pivote lleva tiempo TS(n/b),para algún b natural, b 9. ¿cuán “suficientemente” buena, enfunción de b, tendría que ser la división del arreglo? (Ayuda: usarlas propiedades de las recurrencias.)

el siguiente algoritmo encuentra una aproximación al medianocon tiempo de ejecución en ⇥(TS(bn/5c)+TSbn/5c).






function PseudoMediano(A[1..n])IF n<=5

p ::= MedAdhoc5(A[1..n])ELSE

z ::= piso(n/5)array Medianos[1..z]FOR i ::= 1 TO z

Medianos[i] ::=MedAdhoc5(A[5i-4..5i])

ENDFORp ::= Selección(Medianos[1..z],

techo(z/2))ENDIFRETURN p

Costo Veces

a 1

b 1

c bn/5c

TS(bn/5c) 1






donde MedAdhoc5() es un algoritmo para encontrar elmediano de a los sumo 5 elementos

y por lo tanto es de tiempo ⇥(1).

el tiempo de ejecución de Pseudomediano() es⇥(n)+TS(bn/5c), donde TS() es el tiempo de ejecución delalgoritmo para resolver el problema SELECCIÓN






function Selección(A[i..j],s)p ::= PseudoMediano(A[i..j])PivotearBH(p,A[i..j],k,l)CASEs<=k: r::=Selección(A[i..k],s)k<s<l: r::=ps>=l: s::=s-l+1

r::=Selección(A[l..j],s)ENDCASERETURN r

Costo

⇥(n)+ tS(bn/5c)⇥(n)

TS(k � i +1)⇥(1)⇥(1)

TS(j � l +1)

⇥(1)







el algoritmo anterior genera la recurrencia:

TS(n) =

8>>>><

>>>>:

a si los elementosson iguales,o n 5

⇥(n)+TS(bn/5c)++TS(maxk ,l(k � i +1, j � l +1)) sino

¿porqué? para saberlo es necesario conocer cómo se aproximael pseudomediano al mediano verdadero (ie la relación entrek � i +1 y j � l +1 con n/2 .






LemaLa posición r del resultado del algoritmo Pseudomediano(A)cuando A tiene n elementos es tal que 3

10 n� 65 r 7

10 n+ 65 .

Prueba.











LemaLa posición r del resultado del algoritmo Pseudomediano()cuando A tiene n elementos es tal que 3

10 n�4 r 710 n+ 6

5 .

Prueba.La mínima cantidad de elementos menores o iguales es3d z

2e �310 n� 6

5 . Luego la máxima cantidad de elementos mayores esmenor que n� ( 3

10 n� 65) =

710 n+ 6

5 . Por otro lado, la máximacandidad de elementos menores es a lo sumo2z +3b z

2c+4 710 n+4.






la recurrencia para SELECCIÓN queda entonces

TS(n)

8>><

>>:

a si los elementosson iguales, o n 5

⇥(n)+TS(bn/5c)+maxm7n/10+4(TS(m)) sino

no se puede analizar ni con el teorema maestro ni con laecuación característica.






Teorema

TS(n) 2⇥(n)

Prueba.

Es fácil ver que TS(n) 2 ⌦(n). Para el orden, por inducciónconstructiva sobre n, se encuentran los valores para c y n0 tales queTS(n) cn para todo n � n0.






Quicksort revisado

usando entonces este algoritmo para calcular el mediano, y elpivoteo de la bandera holandesa se puede obtener la siguienteversión de quicksort






Quicksort(A[i..j])IF j-i es pequeño

Inserción(A[i..j])ELSE

piv ::= Mediano(A[i..j])PivotearBH(A[i..j],piv,k,l)Quicksort(A[i..k])Quicksort(A[l..j])

ENDIF

costo

⇥(1)⇥(1)

⇥(n)⇥(n)

T (n/2) peor caso






el tiempo de ejecución es

T (n) =

⇢⇥(1) si n es pequeñoT (n/2)+⇥(n) sino

usando el teorema maestro, T (n) 2⇥(n logn).

¿qué pasa si esta versión de quicksort en lugar de llamar aMediano(), busca el pivote con PseudoMediano()?(ejercicio)





MULTIPLICACIÓN DE MATRICES

se tiene el problema de calcular el producto C de dos matricesA,B cuadradas de dimensión n

el algoritmo directo tiene tiempo de ejecución en ⇥(n3), ya quecada uno de los n2 elementos de C lleva tiempo ⇥(n) encomputarse

si existiera un algoritmo dividir y conquistar que partiera lasmatrices originales en matrices de n/2⇥n/2, 8 o másmultiplicaciones de estas matrices igualaría o empeoraría eltiempo del algoritmo directo (ejercicio).





Algoritmo de Strassen

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

la idea del algoritmo de Strassen es dividir las matrices en cuatropartes iguales, y resolver el producto original en base aoperaciones sobre estas partes

usando sumas y restas entre los componentes de ⇥(n2), enforma análoga al problema de multiplicar enteros grandes





cada una de A11, . . . ,C22 tiene dimensión n2 ⇥

n2 . Sumas y restas

de estas matrices se puede computar en tiempo ⇥(n2)





si se definen las siguientes matrices auxiliares, también de n2 ⇥

n2

M1 = (A21 +A22 �A11)⇥ (B22 �B12 +B11)

M2 = A11 ⇥B11

M3 = A12 ⇥B21

M4 = (A11 �A21)⇥ (B22 �B12)

M5 = (A21 +A22)⇥ (B12 �B11)

M6 = (A12 �A21 +A11 �A22)⇥B22

M7 = A22 ⇥ (B11 +B22 �B12 �B21)

resulta que

C =

✓C11 = M2 +M3 C12 = M1 +M2 +M5 +M6

C21 = M1 +M2 +M4 �M7 C22 = M1 +M2 +M4 +M5

◆





el algoritmo de Strassen tiene tiempo de ejecución

T (n) =

⇢⇥(n3) si n es pequeño7T (n/2)+⇥(n2) sino

resolviendo esta recurrencia con el teorema maestro resultaT (n) 2⇥(nlog7) (ejercicio) si el tamaño n de la matriz espotencia de 2

dado que log2 7 = 2,81 < 3 este algoritmo DYC esasintóticamente mejor que el algoritmo directo





para las matrices cuyos n no son potencia de 2, es necesariocompletarlas con 0’s hasta llegar a una potencia de 2

otros algoritmos similares se han definido siguiendo estaestrategia; se divide a la matriz en b⇥b partes, y se busca unaforma de calcular el producto con k componentes generados apartir de operaciones escalares en las partes tal quelogb k < log2 7.





Definición del problema

sea un conjunto de npuntos en el plano (quesupondremos en el primercuadrante). Problema: sequiere encontrar el par depuntos más cercanos.

el algoritmo directo debe

comparar✓

n2

◆pares de

puntos, por lo que sutiempo está en ⇥(n2).





para aplicar DYC se divideel conjunto de puntos enpartes iguales, por mediode una recta m, según eleje x .

se encuentran entonces d1

y d2 las distancias mínimasen cada parte

pero la solución alproblema original no seencuentra tan fácil a partirde estos dos valores





el par de puntos buscadopuede estar repartido entrelas dos mitades, por lo queni d1 ni d2 necesariamenteson solución

entonces se crea Franja deancho 2d alrededor de larecta m, siendod = min(d1,d2), y sebusca si existe unadistancia menor que d enesa zona





si existe en Franja unadistancia d3 < d entoncesésa es la solución. En casocontrario la solución es d

para que el algoritmo DYCsea más eficiente que elalgoritmo directo, debetenerse cuidado que lasobrecarga de la particióny combinación sean detiempo menor que ⇥(n2)





function MasCercanos(P[1..n])IF n es pequeño

RETURN algoritmoBasico(P)ELSE

m ::= punto medio de coord. xcrear P1 y P2d1 ::= MásCercanos(P1)d2 ::= MásCercanos(P2)d ::= min(d1, d2)crear Franja con ancho 2d de md3 ::= recorrido(Franja)RETURN min(d,d3)

ENDIF

costo

⇥(1)⇥(1)

⇥(1)??

T (bn/2c)T (dn/2e)⇥(1)

????





Implementación

para la creación eficiente de las subinstancias es posible ordenarel arreglo P por coordenadas x una sola vez al comienzo de laejecución, agregando tiempo en ⇥(n logn) por única vezpara la creación de Franja y la búsqueda eficiente en esearreglo se puede:

ordenar el arreglo P también por coordenada ypartirlo de acuerdo a si cada punto pertenece o no a Franjapor cada punto considerar la distancia con solo los 7 siguientesdentro de Franja (esto es suficiente no puede haber más de 8puntos en un rectángulo de 2d ⇥d cuya distancia sea menor oigual a d)






luego se genera la recurrencia:

T (n) =

⇢⇥(1) para n pequeñoT (bn/2c)+T (dn/2e)+⇥(n logn) sino

resolviendo cambio de variables y la regla de funciones decrecimiento suave, resulta T (n) 2⇥(n log2 n).





se puede mejorar el tiempo de ⇥(n log2 n) a costa de incorporarcomo entrada al algoritmo no solo P ordenado por coordenadasx , sino también ordenado por coordenas y .

de esta forma se elimina el ordenamiento en cada llamadarecursiva, realizándose solamente un única vez al comienzo delalgoritmo, y la creación de Franja se puede hacer entonces entiempo lineal

el problema ahora es crear los nuevos arreglos ordenados por ypara cada llamada recursiva; pero esto puede hacerse en tiempolineal a partir del arreglo completo ordenado por y

la recurrencia queda entonces T (n) = 2T (n/2)+⇥(n) quesabemos que está en ⇥(n logn)





Criptografía tradicionalProtocolo RSAExponenciación modular

Criptografía

Esquema para protocolos de Clave Secreta






Esquema de un protocolo de Clave Pública






los protocolos de Clave Pública solo fueron posibles a partir delestudio sistemático de la Algoritmia, a mediados de los ’70s

a continuación se presentará una solución simple propuesta porRivest, Shamir y Adleman conocida como el sistema criptográficoRSA (1978)






Protocolo RSA

B (el receptor del mensaje) elige dos números primos p y q(cuanto más grandes, más difícil de quebrar el cifrado) y calculaz = pq

existen algoritmos eficientes para testear si un número es primo(se verá más adelante un algoritmo probabilístico) y paramultiplicar enteros grandes (ya visto)

sin embargo, no se conocen algoritmos eficientes para factorearz.






B también debe elegir un número n aleatorio, tal que1 < n < z �1, que no tenga factores comunes con (p�1)(q�1)

existe un algoritmo eficiente (basado en el algoritmo de Euclides)que dado cualquier n, no sólo comprueba si cumple con lapropiedad sino que al mismo tiemo calcula el único s tal que1 s z �1 y ns mod (p�1)(q�1) = 1






lo interesante de estos números es que se puede probar que si1 a < z entonces ax

mod z = a, para todo x tal quex mod (p�1)(q�1) = 1

la clave pública está formada por z y n, y la clave secreta (sóloconocida por B) por s

el remitente A del mensaje m, 1 m z �1 (si no cumple conesta restricción, se parte el mensaje en pedazos de ese tamaño)debe calcular c = mn

mod z






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

csmod z = (mn

mod z)smod z = (mn)s

mod z =mnsmod z =m

según la propiedad anterior

es necesario una implementación eficiente de la exponenciaciónmodular xy

mod z

el espía, con conocimiento de c, n y z, sólo puede factorear z enpq para hallar s y calcular m. Se supone que el factoreo denúmeros grandes no se puede realizar en tiempo razonable






Esquema de un protocolo de Clave Pública






Exponenciación modular

Problema: dados enteros grandes m,n,z se quiere calcularmn

mod z.

la solución se obtiene a partir de un algoritmo DYC para calcularexponentes de enteros grandes

usando además las siguientes propiedades:

xymod z = (x mod z)y

mod z

xy mod z = [(x mod z)(y mod z)] mod z






el algoritmo DYC resultasi y es par, y = 2y 0 luego

xymod z = x2y 0

mod z = (x2mod z)y 0

mod z

si y > 1 es impar, y = 2y 0+1 luego

xymod z = x2y 0+1

mod z = x2y 0x mod z =

= [(x2y 0mod z)(x mod z)] mod z

como la instancia se resuelve en base a la solución de un sólosubproblema, se trata de un caso de simplificación






function Expomod(x,y,z)a ::= x mod zIF y=1

RETURN aELSEIF y es par

aux ::= a^2 mod zRETURN Expomod(aux,y/2,z)

ELSEIF y es imparRETURN (a * Expomod(a,y-1,z)) mod z

ENDIF







La recurrencia de su tiempo de ejecución es:

TEXP(y) =

8<

:

⇥(|x |+ |z|) si y = 1TEXP(y/2)+⇥(|z|2) si y es parTEXP(y �1)+⇥(|z|2) si y es impar

ni siquiera es eventualmente no decreciente






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) == TEXP(by/2c)+⇥(|z|2)

con lo que:

TEXP(y)⇢

⇥(|x |+ |z|) si y = 1TEXP(by/2c)+⇥(|z|2) si y < 1

esta nueva recurrencia, que sí es eventualmente no decreciente,tiene como resultado TEXP(y) 2 O(logy), considerandoconstante el costo de las multiplicaciones






análogamente se muestra que TEXP(y) 2 ⌦(logy)

tener en cuenta para ambos casos que y es el valor de uno delos datos de entrada, y no su longitud

este tiempo asintótico se puede mejorar usando el algoritmo DYCpara multiplicación de enteros grandes

esta algoritmo es el algoritmo de encriptación y decriptación delprotocolo RSA.


algoritmos “dividir y conquistar”algoritmos y complejidad algoritmos “dividir y conquistar”...

Documents