Divide y Vencerás

 

Divide y vencerás 1. Método general. 2. Análisis de tiempos t iempos de ejecución. 2.1. Análisis general. 2.2. Caso recursivo. 3. Ejemplos. 3.1. Búsqueda del máximo y el mínimo. 3.2. Ordenación por mezcla y ordenación rápida. 3.3. El problema de selección. 3.4. Multiplicación Multiplicación rápida de enteros largos. 3.5. Multiplicación Multiplicación rápida de matrices.  

1

 

Método general •

La técnica divide y vencerás consiste en descomponer el problema en un conjunto de subproblemas más pequeños. Después se resuelven estos subproblemas y se combinan las soluciones para obtener la solución para el problema original.

•

Esquema general:  divide_venceras divide_ven ceras (p: problema)  problema)  dividir  (p,  (p, p1, p2, ..., pk) para i = 1, 2, ..., k si = resolver (pi) solucion = combinar (s1, s2, ..., sk)

Puede ser recursivo siendo “resolver” una nueva llamada a “divide_venceras”   “divide_venceras” Si el problema es “pequeño”, entonces se puede resolver de forma directa. directa.   •

Ejemplo: Torres de Hanoi  Hanoi   

2

 

Método general •Para que pueda aplicarse la técnica divide y vencerás necesitamos:  –El problema original debe poder dividirse fácilmente en un  –El conjunto de subproblemas, del mismo tipo que el problema original pero con una resolución más sencilla (menos costosa).  –La solución de un subproblema debe obtenerse  –La independientemente independientemen te de los otros.  –Normalmente los subproblemas deben ser de tamaños  –Normalmente parecidos. Como mínimo necesitamos que haya dos subproblemas. Si sólo tenemos un subproblema hablamos de técnicas de reducción (o (o simplificación  simplificación). ).  –Necesitamos  – Necesitamos un método (más o menos directo) de resolver los problemas de tamaño pequeño.  –Es  – Es necesario tener un método de combinar los resultados de los subproblemas.  

3

 

Método general, esquema recursivo • Normalmente para resolver los subproblemas se utilizan llamadas recursivas al mismo algoritmo (aunque no necesariamente). • Esquema recursivo (con división en 2 subproblemas):  subproblemas):  divide_venceras divide_vencera s (p, q: indice) var m: indice si  pequeño (p, q) solucion = solucion_directa (p, q) en otro caso m = dividir  (p,  (p, q); solucion = combinar (divide_ve (divide_venceras nceras (p, m), divide_venceras divide_v enceras (m+1, q));

 

4

 

Análisis de tiempos de ejecución

• Para el esquema recursivo, con división en dos subproblemas: Si nn0 es suficientemente pequeño

g(n) t(n) =

2*t(n/2) + f(n) En otro caso

• t(n): t(n): tiempo de ejecución del algoritmo. • g(n) g(n):: tiempo de comprobar si es pequeño y calcular la solución para el caso base • f(n): f(n): tiempo de comprobar si es pequeño y de dividir el problema y combinar los resultados.

 

5

 

Análisis de tiempos de ejecución

• Desarrollando Desarrollando tenemos: Suponiendo que n es potencia de 2, n = 2 k, y n0 = n/2m. m 1 m

m

t (n) 2 g (n / 2 )

i 

( 2  i  0 

i 

f (n / 2 ))

• Si n0=1, entonces m=k: k 1

k 1

t (n) 2 g (n / 2 )  (2 f (n / 2 ))  n  g (1)   (2 f (2 )) k 

k 

i 

i 0

 

k i 

i 

i 

i 0

6

 

Análisis de tiempos de ejecución • Ejemplo 1. La 1. La resolución directa se puede hacer en un tiempo constante y la combinación de resultados también. g(n) = c; f(n) = d k 1

k 1

t (n) n  g (1)   (2i  f   (2k i  ))  n  c    (2i   d )  n  c   d  (n  1)  O(n) i 0

i 0

• Ejemplo 2. La 2. La solución directa se calcula en O(n2) y la combinación combinació n en O(n). 2

g(n) = c·n ; f(n) = d·n k 1

k 1

k 1

i  k i  k  t (n) n  g (1)   (2i f (2k i  ))  n  c  d  n c  d  ( 2 2 ) 2            i 0 

n  c   d    k   2k 

i 0   

i 0

n  c   d   lo log g 2 n  n  O  (n  lo log g n)

7

 

Análisis de tiempos de ejecución • Si el problema se divide en a llamadas recursivas de tamaño n/b n/b,, y la combinación requiere f(n) = d·n  O(n), entonces: t(n) = a·t(n/b) + d·n Suponiendo n = bk  k = logb n t(bk) = a·t(bk-1) + d·bk  Podemos deducir que: O(nlogba) Si a > b t(n)   O(n·log n) Si a = b O(n) Si a < b • Ejemplo 3. Dividimos 3. Dividimos en 2 trozos de tamaño n/2 (ordenación por mezcla): a=b=2 t(n)  O(n·log n) • Ejemplo 4. Realizamos 4. Realizamos 4 llamadas recursivas con trozos de tamaño n/2. a = 4; b = 2   8 t(n)  O(nlog24) = O(n2)

 

Búsqueda del máximo y del mínimo • Método directo:  directo:  MaxMin (A: array [1..N] of tipo; var Max, Min: tipo)  

Max = A[1] Min = A[1]  para i=2, 3, ..., N si A[i]>Max Max = A[i] en otro caso si A[i] p) o (k

j)

repetir

l = l-1 hasta (A[l] p) mientras k < l intercambiar (k, l) repetir

k = k+1 hasta (A[k] > p) repetir l = l-1 hasta (A[l] Intercambiar (i, l) 

p) 15

 

Ordenación rápida: costes. • Mejor caso. Todas las particiones son de tamaño similar, n/2. t(n) = 2·t(n/2) + b·n + c  (n·log n)

• Peor caso. Se da cuando la matriz está ordenada o inversamente ordeanada. En este caso una partición tiene tamaño 0 y la otra n-1. t(n) = t(n-1) + b·n + c  O(n2) • Caso promedio. Se puede comprobar que tp(n)  (n·log n).  

16

 

El problema de selección • Sea T[1..n] un array (no ordenado) de enteros, y sea s un entero entre 1 y n. El problema de selección consiste selección consiste en encontrar el elemento que se encontraría en la posición s si el array estuviera ordenado. • Si s = n/2, entonces tenemos el problema de encontrar la mediana de T, es decir el valor que es mayor que la mitad de los elementos de T y menor que la otra mitad. • Forma sencilla de sencilla de resolver el problema de selección: Ordenar T y devolver el valor T[s]. Esto requeriría (n·log n)

 

17

 

El problema de selección • Utilizando el procedimiento Pivote podemos resolverlo en O(n).

Selección i = 1 (T: array [1..n]; s: integer) j=n repetir Pivote (i, j, l) si s < l j = l-1 en otro caso si s > l i = l+1 hasta l=s devolver T[l] • El procedimiento es no recursivo. Además es una reducción: el problema es descompuesto en un solo subproblema de tamaño menor. • En el mejor caso, el subproblema es de tamaño n/2:



= t(n/2) t(n)  O(n)es de tamaño n-1: • En elt(n) peor caso +ela·n; subproblema  

18

t(n) = t(n-1) + a·n; t(n)  O(n2)  

Multiplicación Multiplicaci ón rápida de enteros largos • Supongamos que representamos números enteros (de tamaño arbitrariamente grande) mediante listas de cifras. tipo EnteroLargo = puntero a nodo; nodo = registro  valor : 0..9 sig : EnteroLargo

• Con el algoritmo clásico de multiplicación, multiplicamos todos los dígitos de un entero por los del otro y sumamos (con los desplazamientos adecuados). • El algoritmo tendrá un orden de O(n·m), suponiendo n y m las longitudes de los enteros. Si las suponemos iguales, entonces O(n2).  

19

 

Multiplicación Multiplicaci ón rápida de enteros largos u 

w

x

u = w·10S + x

v 

y

z

v = y·10S + z

n/2 

n/2=S

• Podemos aplicar la técnica divide y vencerás: vencerás:  – Divide: los enteros de tamaño n son divididos en tamaño n/2.  – Solucionar los subproblemas de tamaño n/2.  – Combinar: sumar los resultados de los anteriores ante riores (con los desplazamientos adecuados). • Cálculo de la multiplicación con divide y vencerás: u·v = 102S·w·y + 10S·(w·z+x·y) + x·z • El problema de tamaño n es descompuesto en 4 problemas de tamaño n/2. La combinación (sumas y desplazamientos) se realizar+en O(n). 2), no mejora el método • puede t(n) = 4·t(n/2) d·nun  tiempo  O(nlog24lineal ) = O(n 20

clásico.  

Multiplicación Multiplicaci ón rápida de enteros largos • Multiplicación rápida de enteros largos (Karatsuba y Ofman):  Ofman):  u·v = 102S·w·y + 10S·[(w-x)·(z-y) + w·y + x·z] + x·z • En este caso se requieren 3 multiplicaciones de tamaño n/2: t(n) = 3·t(n/2) + d’·n  O(nlog23)  O(n1.59) • El método es asintóticamente mejor que el método clásico. Sin embargo,es lasmuy constantes combinación costosa.son mucho mayores. La

 

21

 

Multiplicación Multiplicaci ón rápida de matrices • Multiplicar dos matrices cuadradas A, B de tamaños nxn. C = AxB; C(i, j) =  A(i, k)·B(k, j); Para todo i, j= 1..n k=1..n

• El método clásico de multiplicación de matrices requiere O(n3). •  Aplicando divide y vencerás, vencerás, cada matriz es dividida en cuatro submatrices de tamaño (n/2)x(n/2): Aij, Bij y Cij. C11 = A11B11 + A12B21  A11   A21 

A12   A22 

x 

B11 

B12 

C11 

C12 

=  B21 

B22 

C21 

C22 

C12 = A11B12 + A12B22 C21 = A21B11 + A22B21 C22 = A21B12 + A22B22 

• Es necesario resolver 8 problemas de tamaño n/2. La combinación de los resultados requiere un tiempo de O(n2). t(n) = 8·t(n/2) + a·n2  • Resolviéndolo obtenemos obtenemos que t(n) t (n) es O(n 3).  

22

 

Multiplicación Multiplicaci ón rápida de matrices • Multiplicación rápida de matrices (Strassen):  (Strassen):  P = (A +A )(B +B ) 11

22

11

Q = (A12+A22) B11

22

C11 = P + S - T + U

R = A11 (B12-B22)

C12 = R + T

S = A22(B21-B11)

C21 = Q + S

T = (A11+A12)B22 U = (A21-A11)(B11+B12)

C22 = P + R - Q + U

V = (A12-A22)(B21+B22) • El tiempo de ejecución 2será: t(n) = 7·t(n/2) + a·n   • Resolvién Resolviéndolo, dolo, tenemos que t(n)  O(nlog27)  O(n2.81). • Las constantes que multiplican al polinomio son mucho mayores (tenemos muchas sumas), por lo que sólo es   23 mejor cuando la entrada es muy grande.