3-Divide y Venceras PDF

Divide y vencers
v
v
v
v
v
v
v
v
v
v
Introduccin
La bsqueda dicotmica
La ordenacin por fusin
El algoritmo de ordenacin
de Hoare
Algoritmos de seleccin y
de bsqueda de la mediana
Multiplicacin de enteros grandes
Potenciacin de enteros
Introduccin a la criptografa
Multiplicacin de matrices
Calendario de un campeonato
2
8
13
15
18
22
29
36
47
52
J. Campos - C.P.S. Esquemas algortmicos - Divide y vencers Pg. 1
El esquema divide y vencers:

Introduccin
v
Tcnica de diseo de algoritmos

divide y vencers:
descomponer el ejemplar a resolver en un cierto
nmero de subejemplares ms pequeos del
mismo problema;
resolver independientemente cada subejemplar;
combinar los resultados obtenidos para construir
la solucin del ejemplar original.
aplicar esta tcnica recursivamente

Introduccin
v
Esquema genrico:
funcin
funcin divide_y_vencers(x:tx)
divide_y_vencers(x:tx) devuelve
devuelve ty
ty
variables
variables xx11,,
,x
,xkk:tx;
:tx; yy11,,
,y
,ykk:ty
:ty
principio
principio
si
si xx es
es suficientemente
suficientemente simple
simple
entonces
entonces devuelve
devuelve solucin_simple(x)
solucin_simple(x)
sino
sino
descomponer
descomponer xx en
en xx11,,
,x
,xkk;;
para
para i:=1
i:=1 hasta
hasta kk hacer
hacer
yyi:=divide_y_vencers(x
ii))
i:=divide_y_vencers(x
fpara;
fpara;
devuelve
devuelve combinar(y
combinar(y11,,
,y
,ykk))
fsi
fsi
fin
fin
Si k=1, el esquema anterior se llama

tcnica de reduccin.

Introduccin
v
Sobre el coste computacional:

Sea un algoritmo A que emplea un tiempo
cuadrtico.
Sea c una constante tal que una implementacin
particular de A emplea un tiempo
tA(n)cn2
para un ejemplar de tamao n.
Supongamos que A se puede descomponer en
tres subejemplares de tamao n/2, resolverlos
y combinar su resultados para resolver A.
Sea d una constante tal que el tiempo empleado
en la descomposicin y combinacin es t(n)dn.

Introduccin
La utilizacin de esta particin da lugar a un
nuevo algoritmo B con un tiempo:
tB (n) = 3t A
(n / 2)+ t (n)
2
n + 1
+ dn
3c
2
3 2 3
3
= cn + c + d n + c
4
2
Luego B es un 25% ms rpido que A.

Si se aplica a B la misma tcnica de descomposicin se obtiene un algoritmo C con tiempo:
t A (n)
si n n 0
tC (n) =
3t C n / 2 + t (n) en otro caso
Donde tA(n) es el tiempo del algoritmo simple, n0

es el umbral por encima del cual el algoritmo se
usa recursivamente y t(n) el tiempo de la
descomposicin y combinacin.
La solucin de la ecuacin en recurrencias da un
tiempo para el algoritmo C de nlog 3 n1,59.

Introduccin
v
Recordar
una de las ecuaciones en recurrencias
especialmente til para el anlisis de
algoritmos de divide y vencers:
La solucin de la ecuacin
T(n) = aT(n/b) + (nklogpn)
con a1, b>1, p0 es
O (nlog b a ),
si a > bk
T (n) O (n k log p+ 1 n) , si a = bk
k
O (n k log p n) ,
si
a
<
b

Introduccin
v
Sobre el clculo del umbral ptimo:

Es un problema complejo.
Para un mismo problema, vara con la implementacin concreta y vara con el valor de n.
Puede estimarse empricamente (tablas,)...
... o tericamente: calculando el n para el que la
solucin recursiva y la solucin simple tienen
igual coste; por ejemplo, si tA(n)=n2 y t(n)=16n:
t A (n) = 3t A ( n / 2 ) + t (n)
da un valor de n064 (ignorando los redondeos).
v
Problema:
Dado T[1..n] vector ordenado crecientemente y
dado x, encontrar x en T, si es que est.
Formalmente: encontrar un natural i tal que
0in y T[i]x<T[i+1], con el convenio de que
T[0]=- y T[n+1]=+ (centinelas).
Solucin secuencial evidente:
funcin
funcin secuencial(T:vector[1..n]de
secuencial(T:vector[1..n]de dato;
dato;
x:dato)
x:dato) devuelve
devuelve 0..n
0..n
variables
variables i:0..n+1;
i:0..n+1; b:booleano
b:booleano
principio
principio
i:=1;
i:=1; b:=falso;
b:=falso;
mq
mq (i
(in)
n) and
and not
not bb hacer
hacer
si
si T[i]>x
T[i]>x
entonces
entonces b:=verdad
b:=verdad
sino
sino i:=i+1
i:=i+1
fsi
fsi
fmq;
fmq;
devuelve
devuelve i-1
i-1
fin
fin
Coste caso promedio y caso peor: (n)
v
Bsqueda dicotmica (algoritmo de

reduccin, puesto que k=1):
funcin
funcin dicotmica(T:vector[1..n]de
dicotmica(T:vector[1..n]de dato;
dato;
x:dato)
x:dato) devuelve
devuelve 0..n
0..n
principio
principio
si
si (n=0)
(n=0) or
or (x<T[1])
(x<T[1]) entonces
entonces devuelve
devuelve 00
sino
sino devuelve
devuelve dicotRec(T,1,n,x)
dicotRec(T,1,n,x)
fsi
fsi
fin
fin
funcin
funcin dicotRec(T:vector[1..n]de
dicotRec(T:vector[1..n]de dato;
dato;
i,d:1..n;
i,d:1..n;
x:dato)
x:dato) devuelve
devuelve 1..n
1..n
{bsqueda
{bsqueda dicotmica
dicotmica de
de xx en
en T[i..d];
T[i..d];
se
se supone
supone que
que T[i]x<T[d+1]
T[i]x<T[d+1] ee id}
id}
variable
variable k:1..n
k:1..n
principio
principio
si
si i=d
i=d entonces
entonces devuelve
devuelve ii
sino
sino
k:=(i+d+1)
k:=(i+d+1) div
div 2;
2;
si
si x<T[k]
x<T[k]
ent
ent devuelve
devuelve dicotRec(T,i,k-1,x)
dicotRec(T,i,k-1,x)
sino
devuelve
sino devuelve dicotRec(T,k,d,x)
dicotRec(T,k,d,x)
fsi
fsi
fsi
fsi
fin
fin
v
Versin iterativa:
funcin
funcin dicotIter(T:vector[1..n]de
dicotIter(T:vector[1..n]de dato;
dato;
x:dato)
x:dato) devuelve
devuelve 0..n
0..n
variables
variables i,d,k:1..n
i,d,k:1..n
principio
principio
si
si (n=0)
(n=0) or
or (x<T[1])
(x<T[1])
entonces
entonces devuelve
devuelve 00
sino
sino
i:=1;
i:=1; d:=n;
d:=n;
mq
mq i<d
i<d hacer
hacer
{T[i]x<T[d+1]}
{T[i]x<T[d+1]}
k:=(i+d+1)
k:=(i+d+1) div
div 2;
2;
si
x<T[k]
si x<T[k]
entonces
entonces d:=k-1
d:=k-1
sino
sino i:=k
i:=k
fsi
fsi
fmq;
fmq;
devuelve
devuelve ii
fsi
fsi
fin
fin
Coste: (log n), en todos los casos.
v
Mejora aparente:
funcin
funcin dicotIter2(T:vector[1..n]de
dicotIter2(T:vector[1..n]de dato;
dato;
x:dato)
x:dato) devuelve
devuelve 0..n
0..n
variable
variable i,d,k:1..n
i,d,k:1..n
principio
principio
si
si (n=0)
(n=0) or
or (x<T[1])
(x<T[1])
entonces
entonces devuelve
devuelve 00
sino
sino
i:=1;
i:=1; d:=n;
d:=n;
mq
mq i<d
i<d hacer
hacer
{T[i]x<T[d+1]}
{T[i]x<T[d+1]}
k:=(i+d)
k:=(i+d) div
div 2;
2;
si
x<T[k]
si x<T[k]
entonces
entonces d:=k-1
d:=k-1
sino
sino
si
si xxT[k+1]
T[k+1]
entonces
entonces i:=k+1
i:=k+1
sino
sino i:=k;
i:=k; d:=k
d:=k
fsi
fsi
fsi
fsi
fmq;
fmq;
devuelve
devuelve ii
fsi
fsi
fin
fin
v
La mejora es slo aparente:

el primer algoritmo realiza siempre (log n)
iteraciones mientras que el segundo puede parar
antes;
clculo del nmero medio de iteraciones
suponiendo que:
u todos los elementos de T son distintos,
u x est en T,
u cada posicin tiene igual probabilidad de
contener a x
[BB90, pp. 116-119]
Iter 1 (n) Iter 2 (n) +
3
2
Es decir, el primer algoritmo realiza, en media,

una iteracin y media ms que el segundo.
Pero, cada iteracin del segundo es ligeramente
ms costosa que la del primero.
Son difcilmente comparables.
Si n es suficientemente grande, el primer
algoritmo es mejor que el segundo.

v
Dado un vector T[1..n] de n elementos

dotados de una relacin de orden total,
se trata de ordenar de forma creciente
esos elementos.
Tcnica de divide y vencers ms
sencilla:
dividir el vector en dos mitades;
ordenar esas dos mitades recursivamente;
fusionarlas en un solo vector ordenado.
algoritmo
algoritmo ordFusin(e/s
ordFusin(e/s T:vect[1..n]de
T:vect[1..n]de dato)
dato)
variables
variables U:vect[1..(n
U:vect[1..(n div
div 2)]de
2)]de dato;
dato;
V:vect[1..((n+1)
V:vect[1..((n+1) div
div 2)]de
2)]de dato
dato
principio
principio
si
si nn es
es pequeo
pequeo
entonces
entonces ordInsercin(T)
ordInsercin(T)
sino
sino
U:=T[1..(n
U:=T[1..(n div
div 2)];
2)];
V:=T[(n
V:=T[(n div
div 22 ++ 1)..n];
1)..n];
ordFusin(U);
ordFusin(U);
ordFusin(V);
ordFusin(V);
fusin(T,U,V)
fusin(T,U,V)
fsi
fsi
fin
fin

v
Coste de ejecucin:
la descomposicin de T en U y V precisa un
tiempo lineal;
la fusin de U y V tambin necesita un tiempo
lineal;
por tanto, si t(n) es el tiempo de ejecucin del
algoritmo para ordenar n elementos,
) (
t (n) t n / 2 + t n / 2 + (n)
es decir, t(n)(nlog n)
v
Adems:
La fusin de T[1..k] y T[k+1..n] (ya ordenados) en
el mismo T[1..n] puede hacerse en tiempo lineal
utilizando slo una cantidad fija de variables
auxiliares (independiente de n).
Ejercicio (vase la solucin del ejercicio 18 de la
seccin 5.2.4 de [Knu73]).
El algoritmo de ordenacin de
Hoare
C.A.R. Hoare: Quicksort,
Computer Journal, 5(1), pp. 10-15, 1962.
algoritmo
algoritmo ordRpida(e/s
ordRpida(e/s T:vect[1..n]de
T:vect[1..n]de dato;
dato;
ent
ent iz,de:1..n)
iz,de:1..n)
{Ordenacin
{Ordenacin de
de las
las componentes
componentes iz..de
iz..de de
de T.}
T.}
variable
variable me:1..n
me:1..n
principio
principio
si
si de-iz
de-iz es
es pequeo
pequeo
entonces
entonces ordInsercin(T,iz,de)
ordInsercin(T,iz,de)
sino
sino
divide(T,iz,de,me);
divide(T,iz,de,me);
{izk<meT[k]T[me]
{izk<meT[k]T[me] me<kdeT[k]>T[me]}
me<kdeT[k]>T[me]}
ordRpida(T,iz,me-1);
ordRpida(T,iz,me-1);
ordRpida(T,me+1,de)
ordRpida(T,me+1,de)
fsi
fsi
fin
fin
Hoare
algoritmo
algoritmo divide(e/s
divide(e/s T:vect[1..n]de
dato;
ent
ent iz,de:1..n;
iz,de:1..n;
sal
sal me:1..n)
me:1..n)
{Permuta
{Permuta los
los elementos
elementos iz..de
iz..de de
de TT de
de forma
forma que:
que:
izmede,
izmede,
k
k t.q.
t.q. izk<me:
izk<me: T[k]p,
T[k]p,
T[me]=p,
T[me]=p,
k
k t.q.
t.q. me<kde:
me<kde: T[k]>p,
T[k]>p,
pp se
llama
pivote
se llama pivote yy es,
es, por
por ejemplo,
ejemplo, el
el valor
valor
inicial
inicial de
de T[iz].
T[iz]. }}
variables
variables p:dato;
p:dato; k:1..n
k:1..n
principio
principio
p:=T[iz];
p:=T[iz];
k:=iz;
k:=iz; me:=de+1;
me:=de+1;
repetir
repetir k:=k+1
k:=k+1 hasta
hasta que
que (T[k]>p)or(k
(T[k]>p)or(kde);
de);
repetir
repetir me:=me-1
me:=me-1 hasta
hasta que
que (T[me]
(T[me]p);
p);
mq
k<me
hacer
mq k<me hacer
intercambiar(T[k],T[me]);
intercambiar(T[k],T[me]);
repetir
repetir k:=k+1
k:=k+1 hasta
hasta que
que T[k]>p;
T[k]>p;
repetir
repetir me:=me-1
me:=me-1 hasta
hasta que
que T[me]
T[me]pp
fmq;
fmq;
intercambiar(T[iz],T[me])
intercambiar(T[iz],T[me])
fin
fin
Hoare
v
Coste en el peor caso: cuadrtico

(si la eleccin del pivote no es adecuada, los
subejemplares no tienen tamao parecido)
Tiempo medio: O(nlog n)

Dem.: [BB90, pp. 123-124]
(la constante multiplicativa es menor que en los
otros algoritmos de ordenacin que hemos visto)
Algoritmos de seleccin y de
bsqueda de la mediana
v
Dado un vector T[1..n] de enteros, la

mediana de T es un elemento m de T
que tiene tantos elementos menores
como mayores que l en T:
{i [1..n ]|
T [i ] < m
}< n / 2 ,
{i [1..n ]|
T [i ] > m n / 2
(ntese que la definicin formal es ms general:

n puede ser par y adems puede haber elementos
repetidos, incluidaPrimera solucin:
Ordenar T y extraer el elemento n/2-simo.
Tiempo (nlog n).
v
Problema ms general: la seleccin

(o clculo de los estadsticos de orden).
Dado un vector T de n elementos y
1kn, el k-simo menor elemento de T
es aquel elemento m de T que satisface:
{i [1..n ]|
T [i ]< m
}< k ,
{i [1..n ]|
T [i ] m k
Es decir, el elemento en posicin k si T estuviese

ordenado crecientemente.
v
Por tanto, la mediana de T es el

n/2-simo menor elemento de T.
Solucin del problema: inspirada en el

algoritmo de ordenacin de Hoare
(pero ahora slo se resuelve uno de los
subejemplares).
funcin
funcin seleccionar(T:vector[1..n]de
seleccionar(T:vector[1..n]de dato;
dato;
k:1..n)
k:1..n) devuelve
devuelve dato
dato
principio
principio
devuelve
devuelve selRec(T,1,n,k)
selRec(T,1,n,k)
fin
fin
funcin
funcin selRec(T:vector[1..n]de
selRec(T:vector[1..n]de dato;
dato;
i,d,k:1..n)
i,d,k:1..n) devuelve
devuelve dato
dato
principio
principio
si
si d-i
d-i es
es pequeo
pequeo entonces
entonces
ordInsercin(T,i,d);
ordInsercin(T,i,d); devuelve
devuelve T[k]
T[k]
sino
sino
divide(T,i,d,m);
divide(T,i,d,m);
si
si m-i+1
m-i+1kk
entonces
entonces selRec(T,i,m,k)
selRec(T,i,m,k)
sino
sino selRec(T,m+1,d,k-(m-i+1))
selRec(T,m+1,d,k-(m-i+1))
fsi
fsi
fsi
fsi
fin
fin
algoritmo
algoritmo divide(e/s
divide(e/s T:vect[1..n]de
dato;
ent
ent i,d:1..n;
i,d:1..n; sal
sal m:1..n)
m:1..n)
{Permuta
{Permuta los
los elementos
elementos i..d
i..d de
de TT de
de forma
forma que:
que:
imd;
imd; k
k t.q.
t.q. ik<m:
ik<m: T[k]p;
T[k]p; T[m]=p;
T[m]=p;
k
k t.q.
t.q. m<kd:
m<kd: T[k]>p;
T[k]>p;
pp es,
por
ejemplo,
es, por ejemplo, el
el valor
valor inicial
inicial de
de T[i].
T[i]. }}
v
Como en el mtodo de ordenacin de

Hoare, una eleccin desafortunada del
pivote conduce en el caso peor a un
tiempo cuadrtico.
No obstante, el coste promedio es

lineal.
Existe una mejora que permite un coste

lineal tambin en el peor caso, pero, en
la prctica, se comporta mejor el
algoritmo anterior [CLR90].
Multiplicacin de enteros
grandes
v
Coste de realizar las operaciones

elementales de suma y multiplicacin:
Es razonable considerarlo constante si los
operandos son directamente manipulables por el
hardware, es decir, no son muy grandes.
Si se necesitan enteros muy grandes, hay que
implementar por software las operaciones.
Enteros muy grandes:

Representacin de un entero de n cifras: puede
hacerse en un vector con un espacio en O(n) bits.
Operaciones de suma, resta: pueden hacerse en
tiempo lineal.
Operaciones de multiplicacin y divisin entera
por potencias positivas de 10: pueden hacerse en
tiempo lineal (desplazamientos de las cifras).
Operacin de multiplicacin con el algoritmo
clsico (o con el de multiplicacin rusa): tiempo
cuadrtico.
grandes
A. Karatsuba e Y. Ofman:
Multiplication of multidigit numbers on automata,
Dokl. Akad. Nauk SSSR, 145, pp. 293-294, 1962.
Tcnica de divide y vencers para la

multiplicacin de enteros muy grandes:
Sean u y v dos enteros de n cifras.
Se descomponen en mitades de igual tamao:
u = 10 s w + x
s
s
con
0
x
<
10
,
0
z
<
10
,y
s
v = 10 y + z
s = n 2
Por tanto, w e y tienen n/2 cifras

n
u
y
n/2
z
n/2
El producto es:
uv = 10 2 s wy + 10 s (wz + xy ) + xz
grandes
funcin
funcin mult(u,v:granEnt)
mult(u,v:granEnt) devuelve
devuelve granEnt
granEnt
variables
n,s:entero;
w,x,y,z:granEnt
variables n,s:entero; w,x,y,z:granEnt
principio
principio
n:=mx(tamao(u),tamao(v));
si
si nn es
es pequeo
pequeo
entonces
entonces devuelve
devuelve multClsica(u,v)
multClsica(u,v)
sino
sino
s:=n
s:=n div
div 2;
2;
s
s
w:=u
w:=u div
div 10
10s;; x:=u
x:=u mod
mod 10
10s;;
s
s
y:=v
y:=v div
div 10
10s;; z:=v
z:=v mod
mod 10
10s;;
2s
devuelve
devuelve mult(w,y)*10
mult(w,y)*102s
s
+(mult(w,z)+mult(x.y))*10
+(mult(w,z)+mult(x.y))*10s
+mult(x,z)
+mult(x,z)
fsi
fsi
fin
fin
grandes
v
Coste temporal:
Las sumas, multiplicaciones por potencias de 10
y divisiones por potencias de 10: tiempo lineal.
Operacin mdulo una potencia de 10: tiempo
lineal (puede hacerse con una divisin, una
multiplicacin y una resta).
Por tanto, si t(n) es el tiempo del algoritmo:
t (n) = 3t
(n 2 )+ t (n 2 )+ (n)
Si n se supone potencia de 2,
( )
t (n) = 4t n 2 + (n)
La solucin de esta recurrencia es:

t (n) O (n 2 )
Y no hemos ganado nada!?
grandes
Truco: calcular wy, wz+xy, y xz haciendo menos
de cuatro multiplicaciones.
Teniendo en cuenta que:
r = (w + x ) (y + z ) = wy + (wz + xy ) + xz
funcin
funcin mult2(u,v:granEnt)
mult2(u,v:granEnt) devuelve
devuelve granEnt
granEnt
variables
n,s:entero;
w,x,y,z,r,p,q:granEnt
variables n,s:entero; w,x,y,z,r,p,q:granEnt
principio
principio
si
si nn es
es pequeo
pequeo
entonces
entonces devuelve
devuelve multClsica(u,v)
multClsica(u,v)
sino
sino
s:=n
s:=n div
div 2;
2;
s
s
w:=u
w:=u div
div 10
10s;; x:=u
x:=u mod
mod 10
10s;;
s
s
y:=v
y:=v div
div 10
10s;; z:=v
z:=v mod
mod 10
10s;;
r:=mult2(w+x,y+z);
r:=mult2(w+x,y+z);
p:=mult2(w,y);
p:=mult2(w,y); q:=mult2(x,z);
q:=mult2(x,z);
2s
s
devuelve
devuelve p*10
p*102s+(r-p-q)*10
+(r-p-q)*10s+q
+q
fsi
fsi
fin
fin
grandes
v
Eficiencia temporal de la versin 2:

Teniendo en cuenta que w+x e y+z pueden
necesitar 1+n/2 cifras,
) (
) (
t 2 (n) t 2 n 2 + t 2 n 2 + t 2 1 + n 2 + (n)
Y por tanto,
( ) ( )
t 2 (n) n log 3 O n 1 , 59
Debido a la constante multiplicativa, el algoritmo

slo es interesante en la prctica para n grande.
Una buena implementacin no debe usar la base
10 sino la base ms grande posible que permita
multiplicar dos cifras (de esa base) directamente en hardware.
grandes
La diferencia entre los rdenes n2 y n1,59 es menos
espectacular que la existente entre n2 y nlog n.
Ejemplo realizado en un computador en base 220:
(computador con palabras de 60 dgitos, que
permite multiplicar directamente nmeros de 20
dgitos binarios)
u Multiplicacin de nmeros de unas 602
cifras (base decimal):
algoritmo clsico: 400 milisegundos
algoritmo mult2: 300 milisegundos
u Multiplicaciones de nmeros de unas 6000
cifras (base decimal):
algoritmo clsico: 40 segundos
algoritmo mult2: 15 segundos
Descomponiendo los operandos en ms de dos
partes se puede lograr la multiplicacin de dos
enteros en un tiempo del orden de n , para
cualquier >1.
Descomponiendo los operandos en n1/2 partes y
usando la transformada de Fourier, se pueden
multiplicar dos enteros de n cifras en un tiempo
O(n log n loglog n).
v
Problema:
Dados los enteros positivos a, n y z, se
trata de calcular an mod z.
Solucin ingenua:
funcin
devuelve
entero
funcin pot0(a,n,z:entero)
pot0(a,n,z:entero)
devuelve
entero
n
{Devuelve
{Devuelve aan mod
mod z.}
z.}
variables
variables r,i:entero
r,i:entero
principio
principio
r:=1;
r:=1;
para
para i:=1
i:=1 hasta
hasta nn hacer
hacer
r:=r*a
r:=r*a
fpara;
fpara;
devuelve
devuelve rr mod
mod zz
fin
fin
Si se quita la operacin mod z final, sirve para

calcular an (no modular).
Si r:=r*a se considera operacin elemental,
el coste est en (n).
Pero NO es as (p.e., 1517 no cabe en 8 bytes).
v
Inconvenientes de esta solucin:

Su coste (el bucle se ejecuta n veces).
Si se quiere aplicar a un entero a grande
(de m cifras), el coste es prohibitivo.
u
(m2n2), si se usa el algoritmo clsico de

multiplicar.
n cifras(r1)=m (r1 denota r tras el 1er paso)
n cifras(ri+1)=m+mi n cifras(ri+1)=i m
n 1
coste = M (m ,i m)
i =1
Mtodo clsico de multiplicar

coste =
u
n 1
cmim
i =1
= cm 2
n 1
i = cm2n 2
i =1
(mlog 3n2), si se usa el algoritmo de divide y

vencers [BB96].
v
Existe un algoritmo ms eficiente para

la potenciacin de enteros.
Por ejemplo, con dos multiplicaciones y elevar al
cuadrado cuatro veces se obtiene:
2
2
x 25 = x 2x x

( )
Ntese que reemplazando en
x 25 = x 2 x
1 1 x
cada x por un 1 y cada 1 por un 0, se obtiene la

secuencia de bits 11001 (expresin binaria de 25).
En otras palabras,
x 25
= x 24 x ;
x 24
( );
x 12
etc.
v
Un algoritmo de eficiencia aceptable:
funcin
devuelve
entero
funcin pot(a,n,z:entero)
pot(a,n,z:entero)
devuelve
entero
n
{Devuelve
{Devuelve aan mod
mod z.}
z.}
variable
variable r:entero
r:entero
principio
principio
si
si n=0
n=0
entonces
entonces devuelve
devuelve 11
sino
sino
si
si nn es
es impar
impar
entonces
entonces
r:=pot(a,n-1,z);
r:=pot(a,n-1,z);
devuelve
devuelve a*r
a*r mod
mod zz
sino
sino
r:=pot(a,n/2,z);
r:=pot(a,n/2,z);
devuelve
devuelve r*r
r*r mod
mod zz
fsi
fsi
fsi
fsi
fin
fin
(Es un algoritmo de reduccin)
v
Sobre la eficiencia de este algoritmo:

Tiempo O(h(n) M(z))
u
h(n) = n de multiplicaciones mdulo z.

M(z) = cota del tiempo para multiplicar dos
enteros menores que z y calcular el mdulo.
Es claro que:
0
si n = 0
h(n) = 1+ h(n 1) si n es impar

1+ h(n / 2) en otro caso
Y, por tanto, h(n) es logartmico en n.
v
Una versin iterativa:
funcin
devuelve
entero
funcin potIter(a,n,z:entero)
potIter(a,n,z:entero)
devuelve
entero
n
{Devuelve
{Devuelve aan mod
mod z.}
z.}
variable
variable i,x,r:entero
i,x,r:entero
principio
principio
i:=n;
i:=n; x:=a;
x:=a; r:=1;
r:=1;
mq
mq i>0
i>0 hacer
hacer
si
si ii es
es impar
impar entonces
entonces r:=r*x
r:=r*x mod
mod zz fsi;
fsi;
x:=x*x
x:=x*x mod
mod z;
z;
i:=i
i:=i div
div 22
fmq;
fmq;
devuelve
devuelve rr
fin
fin
v
Comentarios finales:
Ni la versin recursiva ni la iterativa del
algoritmo de potenciacin presentadas aqu son
las ptimas, pero ambas son razonablemente
buenas.
Suprimiendo de ambos algoritmos los clculos
mod z, se obtienen algoritmos para elevar un
entero cualquiera a a otro cualquiera n.
Su eficiencia depende, obviamente, del algoritmo
que se utilice para multiplicar enteros grandes.
Si a, n y z son nmeros de 200 cifras:
u
el algoritmo potIter puede calcular

an mod z en menos de 1 segundo,
el algoritmo ingenuo pot0 requerira del
orden de 10179 veces la edad del Universo.
Suponiendo que dos enteros de 200 cifras
se multiplican en 1 milisegundo.
v
El problema:
Eva fue un da al teatro con su vecina Alicia y all
le present a sta a su amigo Roberto.
Por razones que no vienen al caso, Alicia

decide enviar a Roberto un mensaje secreto.
Desea hacerlo en una conversacin telefnica,
pero sta puede ser escuchada por Eva.
Eva puede escuchar la informacin que circula
por la lnea pero no puede introducir mensajes ni
modificar los que circulan.
Por supuesto, Alicia no desea que Eva tenga

acceso a sus secretos.
Se trata de encontrar un mtodo que permita a
Alicia conseguir su objetivo.
v
La solucin clsica (usada durante siglos!):

Alicia y Roberto, previamente y en secreto, se
han puesto de acuerdo en una clave k.
Usando la clave k, Alicia puede encriptar su
mensaje m, obteniendo el mensaje cifrado c.
Roberto, al recibir el mensaje c, utiliza la clave k
para descifrarlo y obtener el mensaje original m.
Si Eva intercepta c, como no conoce la clave k, no
podr reconstruir el mensaje m.
Problema actual: telecomunicaciones

Dos ciudadanos necesitan enviarse un mensaje
cifrado mediante correo electrnico por internet
pero no pueden verse previamente en secreto
para acordar una clave k.
Este problema no se resolvi hasta los aos 70!
v
Solucin:
Un sistema criptogrfico de clave pblica.
El ms conocido: el sistema RSA.
R.L. Rivest, A. Shamir y L.M. Adleman:

A method for obtaining digital signatures and
public-key cryptosystems,
Communications of the ACM, 21(2), pp. 120-126, 1978.
Publicado previamente en:

M. Gardner: Mathematical games: A new kind of cipher
that would take millions of years to break,
Scientific American, 237(2), pp. 120-124, 1977.
Plante un problema cuya solucin estim que
necesitara 2 millones de veces la edad del
Universo de clculo ininterrumpido del mejor
computador de aquel momento.
:
:
:
:
:
p, q: nos primos de 100 cifras

z=pq
=(p-1)(q-1)
n: 1nz-1, mcd(n,)=1
()
s: 1sz-1: ns mod =1
(s es nico, me lo guardo!)
() Cmo?
( z, n
J m: mensaje en texto
: a: codificado (ASCII)
(0az-1)
: c: c=an mod z
(c
: a: a=cs mod z ()
: m: mensaje (ASCII)
J Yo tambin
L z, n, c
() Por qu?
v
Clculo de n:
Se genera un valor de n aleatoriamente en (1,z-1).
Despus se intenta calcular s tal que 1sz-1 y
ns mod =1;
u
la teora de nmeros asegura que si existe es

nico y si no existe es porque n no verifica
mcd(n,)=1.
Si no se encuentra tal s es que n no es adecuado

(mcd(n,)1), se vuelve a generar otro n; etc.
v
Clculo de s:
Lema. Sean uv>0 y d=mcd(u,v). Entonces
existen a y b tales que au+bv=d.
Dem.: Si u=v entonces d=v, a=0 y b=1.
Si u>v, sea w=u mod v.
En particular w<v.
Se tiene que d=mcd(v,w).
Por induccin, existen a y b tales que av+bw=d.
Luego a=b y b=a-(u div v)b.
algoritmo
algoritmo tot(ent
tot(ent u,v:entero;
u,v:entero;
sal
sal d,a,b:entero)
d,a,b:entero)
{Pre:
{Pre: u,v>0}
u,v>0} {Post:
{Post: d=mcd(u,v)
d=mcd(u,v) d=au+bv}
d=au+bv}
variables
variables w,aa,bb:entero
w,aa,bb:entero
principio
principio
seleccin
seleccin
u=v:
u=v: d:=v;
d:=v; a:=0;
a:=0; b:=1;
b:=1;
u<v:
tot(v,u,d,b,a);
u<v: tot(v,u,d,b,a);
u>v:
u>v: w:=u
w:=u mod
mod v;
v; {w<v}
{w<v} {d=mcd(v,w)}
{d=mcd(v,w)}
tot(v,w,d,aa,bb);
tot(v,w,d,aa,bb);
a:=bb;
a:=bb; b:=aa-(u
b:=aa-(u div
div v)*bb
v)*bb
fseleccin
fseleccin
fin
fin
Por tanto, para calcular s tal que ns mod =1:
u
u
n, >0
mcd(n,)=1
Calcular s y t tales que ns+t=1.
tot(n,,d,s,t);
tot(n,,d,s,t);
si
si d=1
d=1
entonces
entonces ss es
es el
el buscado
buscado
sino
sino nn no
no es
es bueno
bueno
fsi
fsi
ns + t = 1 ns = 1 t
ns mod = (1 t) mod = 1 0 = 1
v
Falta comprobar la correccin del

mensaje obtenido por Roberto.
Teorema. Sean p,q dos nmeros primos, z=pq,
=(p-1)(q-1) y a tal que 0a<z.
Si x mod =1 entonces ax mod z=a.
Alicia construye su mensaje a, 0a<z, y a partir
de l, calcula c=an mod z.
Roberto calcula
cs mod z=(an mod z)s mod z=ans mod z=a
(porque ns mod =1).
v
Qu puede hacer Eva?

Conoce z, n y c.
Tiene que encontrar a, que es el nico nmero
entre 0 y z-1 tal que c=an mod z.
Es decir, tiene que calcular la raz n-sima de c
mdulo z.
No se conoce ningn algoritmo eficiente para
hacerlo.
v
La mejor solucin conocida es

factorizar z en p y q.
Despus, calcular =(p-1)(q-1), calcular s, y
calcular a igual que Roberto.
Problema: factorizar un nmero de 200

cifras parece imposible con la
tecnologa actual y el estado actual de
la teora de nmeros.
El problema propuesto por Gardner exiga
factorizar un nmero de 129 cifras (Gardner
estim en 2 millones de veces la edad del
Universo el tiempo necesario para resolverlo).
En 1989, se estimaba que ese mismo problema
podra ser resuelto ya en unos 250 aos
CRAY.
Si se trata de un nmero de 200 cifras, la
estimacin suba a 1 milln de aosCRAY.
v
Cuidado!
En abril de 1994, Atkins, Graff, Lenstra y Leyland
han resuelto el problema propuesto por Gardner
en 1977 (que exiga factorizar un nmero de 129
cifras):
u
u
8 meses de clculo, mediante

ms de 600 computadores de todo el mundo
trabajando como una mquina paralela
virtual.
"
V. Strassen: Gaussian elimination is not optimal,
Numerische Mathematik, 13, pp. 354-356, 1969.
Sean A y B dos matrices nn y C su

producto.
El algoritmo clsico calcula:
n
Cij = A ikBkj ; i , j = 1,K,n

k= 1
Es decir, precisa un tiempo (n3).

v
La idea de Strassen es reducir el

nmero de multiplicaciones a costa de
aumentar el nmero de sumas y restas
e introducir variables auxiliares
(como en la multiplicacin de enteros
grandes).
v
Veamos el caso 22:

a a
b b
A = 11 12 y B = 11 12
a21 a22
b21 b22
Algoritmo clsico: 8 multiplicaciones y 4 sumas

Reduccin:
m1 = (a21 + a22 a11 )(b22 b12 + b11 )
m 2 = a11b11
m 3 = a12b21
m 4 = (a11 a21 )(b22 b12 )
m 5 = (a21 + a22 )(b12 b11 )
m 6 = (a12 a21 + a11 a22 )b22
m 7 = a22 (b11 + b22 b12 b21 )
m 2 + m3
m1 + m2 + m 5 + m6
AB =
m1 + m 2 + m 4 m7 m 1 + m 2 + m 4 + m5
Es decir, 7 multiplicaciones y 24 sumas y restas.

Notar que el nmero de sumas y restas puede
reducirse a 15 utilizando ms variables auxiliares
para evitar clculos repetidos, como el de
m1 + m 2 + m 4
v
Caso 2n2n:
Si cada elemento de A y B del caso 22 lo
sustituimos por una matriz nn, se pueden
multiplicar dos matrices 2n2n realizando:
u 7 multiplicaciones de matrices de nn, y
u 15 sumas y restas de matrices de nn.
Coste:
Una suma de matrices nn est en (n2).
Suponer que n es potencia de 2; se obtiene la
recurrencia:
( )
T (n) = 7T n 2 + (n 2 )
Es decir, se pueden multiplicar matrices en

tiempo (nlog 7)O(n2,81).
v
Y si n no es potencia de 2?
v
Si n no es potencia de 2:
Solucin ms fcil: aadir filas y columnas nulas
hasta que lo sea.
Solucin sugerida por Strassen:
u
Para todo entero n es siempre posible

encontrar enteros m y k tales que n=m2k.
Por tanto, una matriz nn se puede partir en
2k2k submatrices de mm.
Entonces, se aplica el mtodo de divide y
vencers hasta que hay que multiplicar
matrices mm y entonces se usa el mtodo
clsico.
(Ntese que si, por ejemplo, n es impar, el
mtodo no sirve.)
v
Comentarios finales sobre el algoritmo

de Strassen:
Segn algunos estudios empricos y debido a la
constante multiplicativa, para que se
noten mejoras con respecto al algoritmo clsico,
n debe ser superior a 100, y la matriz densa.
Es menos estable que el algoritmo clsico (i.e.,
para errores similares en los datos produce
mayores errores en el resultado).
Es ms difcil de implementar que el algoritmo
clsico.
Es difcilmente paralelizable, mientras que el
clsico puede ser fcilmente paralelizado.
El algoritmo clsico precisa un espacio adicional
de tamao constante, mientras que el algoritmo
de Strassen precisa un espacio adicional mayor.
El algoritmo de Strassen ha tenido una
repercusin fundamentalmente terica
(diotambin para otras operaciones basadas en l
(inversin de matrices, determinantes,).
Se conocen algoritmos tericamente mejores
(la actual cota superior est en O(n2,376)).
v
El problema:
En una competicin deportiva se enfrentan n
participantes.
Debe confeccionarse un calendario para que cada
participante juegue exactamente una vez con
cada adversario.
Adems, cada participante debe jugar
exactamente un partido diario.
Supongamos, por simplificar, que n=2k.
v
La representacin de los datos y de la

solucin:
Participantes: 1, 2, , n.
Cada participante debe saber el orden en el que
se enfrenta a los n-1 restantes.
Por tanto, la solucin puede representarse en una
matriz n(n-1).
das
644
47444
8
1
2
3
4
participantes 5
6
7
8
1
2
1
4
3
6
5
8
7
2
3
4
1
2
7
8
5
6
3
4
3
2
1
8
7
6
5
4
5
8
7
6
1
4
3
2
5
6
5
8
7
2
1
4
3
6
7
6
5
8
3
2
1
4
7
8
7
6
5
4
3
2
1
El elemento (i,j), 1in, 1jn-1, contiene el

nmero del participante contra el que el
participante i-simo compite el da j-simo.
v
Solucin de fuerza bruta:

1. Se obtiene para cada participante i, 1in, el
conjunto P(i) de todas las permutaciones posibles
del resto de los participantes {1..n}\{i}.
2. Se completan las filas de la matriz de todas las
formas posibles, incluyendo en cada fila i algn
elemento de P(i).
3. Se elige cualquiera de las matrices resultantes en
la que toda columna j, 1jn-1, contiene nmeros
distintos (nadie puede competir el mismo da
contra dos participantes).
Cada conjunto P(i) consta de (n-1)! elementos.
La matriz tiene n filas.
Hay n! formas distintas de rellenar la matriz.
Es demasiado costoso!
v
Una solucin mediante la tcnica de

divide y vencers (caso n=2k, k>0):
Caso bsico: n=2, basta con una competicin.
Caso a dividir: n=2k, con k>1.
u Se elaboran independientemente dos
subcalendarios de 2k-1 participantes:
Uno para los participantes 1..2k-1, y
otro para los participantes 2k-1+1..2k.
u Falta elaborar las competiciones cruzadas
entre los participantes de numeracin
inferior y los de numeracin superior.
Se completa primero la parte de los
participantes de numeracin inferior:
1er participante: compite en das sucesivos con los participantes de
numeracin superior en orden
creciente.
2 participante: toma la misma secuencia y realiza una permutacin cclica de
un participante.
Se repite el proceso para todos los
participantes de numeracin inferior.
Para los de numeracin superior se
hace lo anlogo con los de inferior.
1
1 2
2 1
1
3 4
4 3
1
2
3
4
1
2
1
4
3
2
3
4
1
2
1
5 6
6 5
3
4
3
2
1
1
2
3
4
5
6
7
8
1
7 8
8 7
5
6
7
8
1
2
1
4
3
6
5
8
7
2
3
4
1
2
7
8
5
6
3
4
3
2
1
8
7
6
5
4
5
8
7
6
1
4
3
2
5
6
5
8
7
2
1
4
3
6
7
6
5
8
3
2
1
4
1
6
5
8
7
2
7
8
5
6
3
8
7
6
5
7
8
7
6
5
4
3
2
1
tipo
tipo tabla=vector[1..n,1..n-1]
tabla=vector[1..n,1..n-1] de
de 1..n
1..n
algoritmo
algoritmo calendario(sal
calendario(sal t:tabla)
t:tabla)
{Devuelve
de
{Devuelve en
en tt al
al calendario
calendario
de competicin
competicin de
de
k
nn participantes,
con
n=2
,
k>0.}
k
participantes, con n=2 , k>0.}
principio
principio
formarTabla(t,1,n)
formarTabla(t,1,n)
fin
fin
algoritmo
algoritmo formarTabla(sal
formarTabla(sal t:tabla;
t:tabla;
ent
ent inf,sup:1..n)
inf,sup:1..n)
{Forma
{Forma la
la parte
parte de
de tabla
tabla correspondiente
correspondiente aa los
los
enfrentamientos
enfrentamientos de
de los
los participantes
participantes inf..sup}
inf..sup}
variable
variable medio:1..n
medio:1..n
principio
principio
si
si inf:=sup-1
inf:=sup-1
entonces
entonces t[inf,1]:=sup;
t[inf,1]:=sup; t[sup,1]:=inf
t[sup,1]:=inf
sino
sino
medio:=(inf+sup)
medio:=(inf+sup) div
div 2;
2;
formarTabla(t,inf,medio);
formarTabla(t,inf,medio);
formarTabla(t,medio+1,sup);
formarTabla(t,medio+1,sup);
completarTabla(t,inf,medio,
completarTabla(t,inf,medio,
medio,sup-1,medio+1);
medio,sup-1,medio+1);
completarTabla(t,medio+1,sup,
completarTabla(t,medio+1,sup,
medio,sup-1,inf)
medio,sup-1,inf)
fsi
fsi
fin
fin
algoritmo
algoritmo completarTabla(ent/sal
completarTabla(ent/sal t:tabla;
t:tabla;
ent
eqInf,eqSup,
ent eqInf,eqSup,
daInf,daSup,
daInf,daSup,
eqInic:1,,n)
eqInic:1,,n)
{Rellena
{Rellena t[eqInf..eqSup,daInf..daSup]
t[eqInf..eqSup,daInf..daSup] con
con
permutaciones
cclicas
empezando
en
eqInic}
permutaciones cclicas empezando en eqInic}
principio
principio
para
para j:=daInf
j:=daInf hasta
hasta daSup
daSup hacer
hacer
t[eqInf,j]:=eqInic+j-daInf
t[eqInf,j]:=eqInic+j-daInf
fpara;
fpara;
para
para i:=eqInf+1
i:=eqInf+1 hasta
hasta eqSup
eqSup hacer
hacer
t[i,daInf]:=t[i-1,daSup];
t[i,daInf]:=t[i-1,daSup];
para
para j:=daInf+1
j:=daInf+1 hasta
hasta daSup
daSup hacer
hacer
t[i,j]:=t[i-1,j-1]
t[i,j]:=t[i-1,j-1]
fpara
fpara
fpara
fpara
fin
fin
v
Coste temporal:
Recurrencia:
( )
T (n) = 2T n 2 + n 2 4
Por tanto, O(n2).
Y si n no es potencia de 2?
Supongamos que est resuelto para n par.
Si n es impar (mayor que 1), no bastan con n-1
das para la competicin, sino que se necesitan n.
Basta con resolver el problema resultante de
aadir un participante (ficticio) ms: el n+1.
Como n+1 es par, podemos calcular el
calendario, que consta de n das.
Una vez resuelto, si al participante i-simo le
toca jugar el da j-simo contra el participante
n+1 (ficticio), eso significa que j es el da de
descanso para el participante i.
v
Y si n es par?
Si n div 2 es par, se puede aplicar el algoritmo
formarTabla (visto para el caso n=2k).
Si n div 2 es impar:
Paso 1:
u Se calcula la primera parte de la competicin
para los n div 2 participantes de numeracin
inferior, aadiendo un participante ficticio.
u Se calcula la primera parte de la competicin
para los otros n div 2 participantes ,
aadiendo otro participante ficticio.
Paso 2:
u El da j-simo, 1jn div 2, se hace jugar
entre s a los dos participantes, uno de
numeracin inferior y otro superior, a los
que les haba tocado el j como da de
descanso en el Paso anterior.
Paso 3:
u Se completa el resto de la tabla con
competiciones cruzadas, de forma parecida
a como se hizo en el algoritmo
completarTabla.
1
2
1
2
1
3
c
1
c
3
.
.
.
1 2 3
1
2
3
c
2
1
c
3
3
c
1
2
.
.
.
1 2 3
4
5
a
d
c
3
2
1
5
4
d
a
a
d
4
5
d
a
5
4
.
.
.
1 2 3 4 5
1
2
3
4
5
a
2
1
a
5
4
3
3
5
1
a
2
4
1
2
3
4
5
6
7
8
9
10
4
3
2
1
a
5
5
a
4
3
1
2
.
.
.
1 2
a
4
5
2
3
1
6 7 8 9
7
6 10 8
8
b 6 7
9 10 b 6
10 9 7 b
b
8 9 10
10
b
9
8
6
7
b
9
10
7
8
6
1 2
2
1
8
5
4
7
6
3
10
9
4
3
2
1
10
9
8
7
6
5
5
7
4
3
1
10
2
9
8
6
6
4
5
2
3
1
9
10
7
8
8
9
10
6
7
4
5
1
2
3
9
10
6
7
8
3
4
5
1
2
10
6
7
8
9
2
3
4
5
1
7
8
9
10
6
5
1
2
3
4
3
5
1
9
2
8
10
6
4
7

3-Divide y Venceras PDF

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

3-Divide y Venceras PDF

Uploaded by

Copyright:

Available Formats

Divide y vencers

J. Campos - C.P.S. Esquemas algortmicos - Divide y vencers Pg. 1

El esquema divide y vencers:

Tcnica de diseo de algoritmos

J. Campos - C.P.S. Esquemas algortmicos - Divide y vencers Pg. 2

El esquema divide y vencers:

Si k=1, el esquema anterior se llama

J. Campos - C.P.S. Esquemas algortmicos - Divide y vencers Pg. 3

El esquema divide y vencers:

Sobre el coste computacional:

J. Campos - C.P.S. Esquemas algortmicos - Divide y vencers Pg. 4

El esquema divide y vencers:

Luego B es un 25% ms rpido que A.

Donde tA(n) es el tiempo del algoritmo simple, n0

J. Campos - C.P.S. Esquemas algortmicos - Divide y vencers Pg. 5

El esquema divide y vencers:

J. Campos - C.P.S. Esquemas algortmicos - Divide y vencers Pg. 6

El esquema divide y vencers:

Sobre el clculo del umbral ptimo:

da un valor de n064 (ignorando los redondeos).

J. Campos - C.P.S. Esquemas algortmicos - Divide y vencers Pg. 7

Bsqueda dicotmica (algoritmo de

J. Campos - C.P.S. Esquemas algortmicos - Divide y vencers Pg. 10

La mejora es slo aparente:

Es decir, el primer algoritmo realiza, en media,

J. Campos - C.P.S. Esquemas algortmicos - Divide y vencers Pg. 12

La ordenacin por fusin

Dado un vector T[1..n] de n elementos

La ordenacin por fusin

J. Campos - C.P.S. Esquemas algortmicos - Divide y vencers Pg. 14

J. Campos - C.P.S. Esquemas algortmicos - Divide y vencers Pg. 15

J. Campos - C.P.S. Esquemas algortmicos - Divide y vencers Pg. 16

Coste en el peor caso: cuadrtico

Tiempo medio: O(nlog n)

J. Campos - C.P.S. Esquemas algortmicos - Divide y vencers Pg. 17

Dado un vector T[1..n] de enteros, la

(ntese que la definicin formal es ms general:

J. Campos - C.P.S. Esquemas algortmicos - Divide y vencers Pg. 18

Problema ms general: la seleccin

Es decir, el elemento en posicin k si T estuviese

Por tanto, la mediana de T es el

Solucin del problema: inspirada en el

J. Campos - C.P.S. Esquemas algortmicos - Divide y vencers Pg. 19

Como en el mtodo de ordenacin de

No obstante, el coste promedio es

Existe una mejora que permite un coste

J. Campos - C.P.S. Esquemas algortmicos - Divide y vencers Pg. 21

Coste de realizar las operaciones

Enteros muy grandes:

J. Campos - C.P.S. Esquemas algortmicos - Divide y vencers Pg. 22

Tcnica de divide y vencers para la

Por tanto, w e y tienen n/2 cifras

J. Campos - C.P.S. Esquemas algortmicos - Divide y vencers Pg. 23

J. Campos - C.P.S. Esquemas algortmicos - Divide y vencers Pg. 24

La solucin de esta recurrencia es:

Y no hemos ganado nada!?

J. Campos - C.P.S. Esquemas algortmicos - Divide y vencers Pg. 25

J. Campos - C.P.S. Esquemas algortmicos - Divide y vencers Pg. 26

Eficiencia temporal de la versin 2:

Debido a la constante multiplicativa, el algoritmo

J. Campos - C.P.S. Esquemas algortmicos - Divide y vencers Pg. 27

J. Campos - C.P.S. Esquemas algortmicos - Divide y vencers Pg. 28

Si se quita la operacin mod z final, sirve para