Algoritmos Divide y Vencers

Anlisis y Diseo de Algoritmos

Algoritmos Divide y Vencers

Ejemplo: Multiplicacin de enteros grandes

La tcnica divide y vencers

Caractersticas

Mtodo general divide y vencers

Eficiencia de los algoritmos divide y vencers

Aspectos de diseo

Determinacin del umbral

Aplicaciones

1
Multiplicacin de enteros
Multiplicacin de enteros de n cifras:
Algoritmo clsico

1234*5678 = 1234* (5*1000 + 6*100+7*10+8)

= 1234*5*1000 + 1234*6*100 + 1234*7*10 + 1234*8

Operaciones bsicas:

Multiplicaciones de dgitos: O(1)

Sumas de dgitos: O(1)

Desplazamientos: O(1)

2
Eficiencia algoritmo: O(n2)

Multiplicacin de enteros
Multiplicacin de enteros de n cifras:
Algoritmo divide y vencers simple

1234 = 12*100 + 34
5678 = 56*100 + 78

1234*5678 = (12*100 + 34)*(56*100 + 78)

= 12*56*10000 + (12*78+34*56)*100 + (34*78)

Idea: Se reduce una multiplicacin de 4 cifras

a cuatro multiplicaciones de 2 cifras,
ms tres sumas y varios desplazamientos. 3
Multiplicacin de enteros
Multiplicacin de enteros de n cifras:
Algoritmo divide y vencers simple

1. Dividir
X = 12345678 = xi*104 + xd xi=1234 xd
xd=5678
=5678
Y = 24680135 = yi*104 + yd
yi*10 yi
yi=2468
=2468 yd=0135

2. Combinar
X*Y = (xi*104 + xd
xd)) * (yi*104 + yd)
(yi*10
= xi*yi*108 + (xi*yd+xd
xi*yi*10 (xi*yd+xd* *yi )*104 + xd
yi)*10 xd*yd
*yd
4

Multiplicacin de enteros
Multiplicacin de enteros de n cifras:
Algoritmo divide y vencers simple

En general:

X = xi*10n/2 + xd
Y = yi*10n/2 + yd
yi*10
X*Y = (xi*10n/2 + xd
xd)) * (yi*10n/2 + yd)
(yi*10
= xi*yi*10n + (xi*yd+xd
xi*yi*10 (xi*yd+xd* *yi )*10n/2 + xd
yi)*10 xd*yd
*yd

5
Multiplicacin de enteros
funcin multiplica (X,Y,n
(X,Y,n)
)
{
if (P es pequeo) {
return X*Y;
} else {
Obtener xi, xd,
xd, yi,
yi, yd; // DIVIDIR
z1 = multiplica (xi, yi,
yi, n/2);
z2 = multiplica (xi, yd, n/2);
z3 = multiplica (xd
(xd,, yi,
yi, n/2);
z4 = multiplica (xd
(xd,, yd, n/2);
aux = suma(z2,z3); // COMBINAR
z1 = desplaza_izq
desplaza_izq(z1,n);
(z1,n);
aux = desplaza_izq
desplaza_izq((aux,n
aux,n/2);
/2);
z = suma(z1,aux);
z = suma(z,z4);
return z;
}
6
}

Multiplicacin de enteros
funcin multiplica (X,Y,n
(X,Y,n)
) Eficiencia
{
if (P es pequeo) { O(1)
return X*Y; O(1)
} else {
Obtener xi, xd,
xd, yi,
yi, yd; O(n)
z1 = multiplica (xi, yi,
yi, n/2); T(n/2)
z2 = multiplica (xi, yd, n/2); T(n/2)
z3 = multiplica (xd
(xd,, yi,
yi, n/2); T(n/2)
z4 = multiplica (xd
(xd,, yd, n/2); T(n/2)
aux = suma(z2,z3); O(n)
z1 = desplaza_izq
desplaza_izq(z1,n);
(z1,n); O(n)
aux = desplaza_izq
desplaza_izq((aux,n
aux,n/2);
/2); O(n)
z = suma(z1,aux); O(n)
z = suma(z,z4); O(n)
return z; O(1)
}
7
}
Multiplicacin de enteros
Multiplicacin de enteros de n cifras:
Algoritmo divide y vencers simple

T(n) = 4T(n/2) + n O(n2)

El cuello de botella est en el nmero de

multiplicaciones de tamao n/2.

Para mejorar la eficiencia debemos reducir el nmero

de multiplicaciones necesario

Multiplicacin de enteros
Multiplicacin de enteros de n cifras:
Algoritmo divide y vencers

r = (xi+xd
(xi+xd)*(
)*(yi+yd
yi+yd)) = xi*yi
xi*yi + (xi*yd+xd
(xi*yd+xd**yi
yi)) + xd
xd*yd
*yd
p = xi*yi
xi*yi
q = xd
xd*yd
*yd

X*Y = p*10n + (r-

(r-p-q)*10n/2 + q

Luego podemos realizar una multiplicacin de tamao n

a partir de 3 multiplicaciones de tamao n/2.
9
Multiplicacin de enteros
funcin multiplicaDV (X,Y,n
X,Y,n))
{
if (P es pequeo) {
return X*Y;
} else {
Obtener xi, xd,
xd, yi,
yi, yd; // DIVIDIR
s1 = suma(xi,xd
suma(xi,xd);
);
s2 = suma(yi,yd
suma(yi,yd);
);
p = multiplicaDV (xi, yi,yi, n/2);
q = multiplicaDV (xd,
xd, yd, n/2);
r = multiplicaDV (s1, s2, n/2);
aux = suma(r,
suma(r,--p,-
p,-q); // COMBINAR
aux = desplaza_izq
desplaza_izq( (aux,n
aux,n/2);
/2);
p = desplaza_izq
desplaza_izq((p,n
p,n);
);
z = suma(p,aux,q
suma(p,aux,q);
);
return z;
}
10
}

Multiplicacin de enteros
funcin multiplicaDV (X,Y,n
X,Y,n)) Eficiencia
{
if (P es pequeo) { O(1)
return X*Y; O(1)
} else {
Obtener xi, xd,
xd, yi,
yi, yd; O(n)
s1 = suma(xi,xd
suma(xi,xd);
); O(n)
s2 = suma(yi,yd
suma(yi,yd);
); O(n)
p = multiplicaDV (xi, yi,yi, n/2); T(n/2)
q = multiplicaDV (xd,
xd, yd, n/2); T(n/2)
r = multiplicaDV (s1, s2, n/2); T(n/2)
aux = suma(r,
suma(r,--p,-
p,-q); O(n)
aux = desplaza_izq
desplaza_izq( (aux,n
aux,n/2);
/2); O(n)
p = desplaza_izq
desplaza_izq((p,n
p,n);
); O(n)
z = suma(p,aux,q
suma(p,aux,q);
); O(n)
return z; O(1)
}
11
}
Multiplicacin de enteros
Multiplicacin de enteros de n cifras:
Algoritmo divide y vencers

T (n) = 3T(n/2) + n O(n log 2 3 ) = O (n1.585 )

Implementacin Implementacin
bsica eficiente
Operaciones n2 n1.585
n = 10 0.1 ms 0.04 ms
n = 100 10 ms 1.48 ms
n = 1000 1 segundo 56.9 ms
n = 10000 100 segundos 2.19 segundos
12

La tcnica divide y vencers

La tcnica divide y vencers (DV) consiste en:

Descomponer el problema que hay que resolver en

cierto nmero de subproblemas ms pequeos del
mismo tipo.

Resolver de forma sucesiva e independiente todos

estos subproblemas
subproblemas..

Combinar las soluciones obtenidas para obtener la

solucin del problema original.
13
La tcnica divide y vencers
Caractersticas de los problemas
resolubles utilizando divide y vencers

El problema se puede descomponer en otros del mismo

tipo que el original y de tamao ms pequeo
(formulacin recursiva).

Los subproblemas pueden resolverse de manera
independiente.

Los subproblemas son disjuntos, sin solapamiento.

La solucin final se puede expresar como combinacin
de las soluciones de los subproblemas.
subproblemas.

14

La tcnica divide y vencers

Mtodo general divide y vencers

DV(x)
if (x es suficientemente pequeo)
pequeo) {
return algoritmo_especfico
algoritmo_especfico(x)
(x);
;
} else {
descomponer x en {x1,, xk}
for i = 1 to k
yi DV(xi)
y recombinar (y1, , yk)
return y;
}

15
La tcnica divide y vencers
Eficiencia de los algoritmos divide y vencers

n
T ( n ) = aT + g ( n )
b
con g (n)O( n k ), a 1, b 2, k 0

( n k ), a < bk

T ( n ) = ( n k logb (n )), a = b k
( n logb ( a ) ) a > b k
16

Aspectos de diseo

Algoritmo recursivo
Divisin del problema en subproblemas
y combinacin eficiente de las soluciones parciales.

Los subproblemas deben tener,
aproximadamente, el mismo tamao.

Algoritmo especfico
para resolver problemas de tamao pequeo.

Determinacin del umbral

para decidir cundo finalizar la descomposicin recursiva
del problema y aplicar el algoritmo especfico.
17
Determinacin del umbral

Umbral ptimo dependiente de la implementacin::
Es difcil hablar del valor adecuado para el umbral n0 si
no tratamos con implementaciones concretas, ya que
gracias a ellas conocemos las constantes ocultas que nos
permitirn afinar el clculo de la eficiencia del algoritmo.

De partida, no hay restricciones sobre el valor que puede

tomar el umbral.
p.ej. Un umbral ptimo infinito supondra no aplicar
nunca DV de forma efectiva (siempre usaramos el
algoritmo especfico).

18

Determinacin del umbral

Mtodo experimental

Implementamos el algoritmo bsico (AB) y el algoritmo
divide y vencers (DV).

Resolvemos para distintos valores de n con ambos
algoritmos: Conforme n aumente, el tiempo requerido
por el algoritmo bsico ir aumentando ms que el del
algoritmo divide y vencers.

19
Determinacin del umbral
Mtodo terico

La idea del mtodo experimental se traduce en

T(n) = h(n) si n n0 (algoritmo bsico)
T(n) = a T(n/b) + g(n) si n > n0 (algoritmo DV)

Tericamente, el umbral ptimo ser cuando coinciden

los tiempos de ejecucin de los dos algoritmos:
h(n) = T(n) = a h(n/b) + g(n), n = n0

20

Determinacin del umbral

Mtodo hbrido

Calculamos las constantes ocultas utilizando un enfoque

emprico (mtodo experimental).

Calculamos el umbral utilizando el criterio empleado para
calcular el umbral terico (mtodo terico)

Probamos valores alrededor del umbral terico
(umbrales de tanteo) para determinar el umbral ptimo.

21
Determinacin del umbral
Ejemplo: Multiplicacin de enteros grandes
T(n) = 3T(n/2) + g(n)
g(n) = 16n (ms
(ms))
h(n) = n2 (ms)
ms)

p.ej. n=1024 n0 = 1 t(n) = 31m 56s

n0 = t(n) = 17m 29s

h(n) = 3 h(n/2) + g(n)

n2 = n2 + 16 n n = n + 16 n0 = 64
n0 = 64 t(n) = 7m 44s 22

Aplicaciones

Algoritmo de bsqueda binaria.

Algoritmos de ordenacin (Mergesort
(Mergesort,, Quicksort).
Quicksort).

Problema de la seleccin (p.ej. mediana)

Exponenciacin rpida.

Multiplicacin de matrices: Algoritmo de Strassen
Strassen..

Subsecuencia de suma mxima.

Par de puntos ms cercano.

Eliminacin de superficies ocultas.

Nmero de inversiones (rankings).

FFT: Transformada Rpida de Fourier (convoluciones
(convoluciones).
).

Interacciones entre n partculas.
23

Calendario de una liga