Divide

& Conquer
Ignacio Decia

Temario

Introduccin
Esquema general
Ejemplos
Observaciones y conclusiones

Introduccin
Divide & Conquer es una tcnica para la resolucin
de problemas que aplica los siguientes pasos:
1. Se descompone el problema original en
subproblemas ms pequeos.
2. Se resuelven los subproblemas de manera
independiente.
3. Finalmente se combinan adecuadamente las
soluciones de los subproblemas para encontrar
la solucin al problema original.

Introduccin
Con subproblemas ms pequeos nos
referimos a instancias de menor tamao del
problema original.
La misma tcnica puede aplicarse nuevamente
a los subproblemas.
Si el subproblema es pequeo se resuelve
directamente, de lo contrario, se aplica
nuevamente la misma idea de
descomposicin.

Introduccin
Problema
P

Introduccin
Problema
P
Dividir

P1

Dividir

P2

Introduccin
Problema
P

P1
Dividir

P11

Dividir
P12

P2
Dividir

P13

Introduccin
Problema
P

P1

P2
Dividir

P11

P12

P13

P21

Dividir

P22

Introduccin
Problema
P

P1

P11

P12

P2

P13

P21

P22

Introduccin
Problema
P

P1

P11
Resolver

P12
Resolver

P2

P13
Resolver

P21

P22

Introduccin
Problema
P

P1
Combinar

P2
Combinar

Combinar
P11

P12

P13

P21

P22

Introduccin
Problema
P

P1

P2

P21

P22

Introduccin
Problema
P

P1

P2

P21
Resolver

P22
Resolver

Introduccin
Problema
P

P1

P2
Combinar

P21

Combinar
P22

Introduccin
Problema
P

P1

P2

Introduccin
Problema
P
Combinar

P1

Combinar

P2

Introduccin
Problema
P

Denicin formal
Dado un problema P, con una entrada de
tamao n, se lo descompone en Pi
subproblemas , cada uno de ellos con tamao
0 < ni < n.
Se resuelve cada uno de los Pi subproblemas
(eventualmente aplicando la misma idea de
descomposicin).
Finalmente se combinan las soluciones para
hallar la solucin del problema P.

Esquema general
Solucion DivideAndConquer (Problema P) {
Solucion S;
Problema [] subproblemas;
Solucion[] subsoluciones;
if (EsCasoBase(P)) {
S = ResolverDirectamente(P);
}
else {
int R = Dividir(P,subproblemas);
for (int i = 1; i <= R; i++) {
subsoluciones[i] = DivideAndConquer(subproblemas[i]);
}
S = Combinar(subsoluciones);
}
return S;
}

Esquema general
Solucion DivideAndConquer (Problema P) {
Solucion S;
Problema [] subproblemas;
Solucion[] subsoluciones;
if (EsCasoBase(P)) {
S = ResolverDirectamente(P);
ESPECFICO DE CADA
}
PROBLEMA
else {
int R = Dividir(P,subproblemas);
for (int i = 1; i <= R; i++) {
subsoluciones[i] = DivideAndConquer(subproblemas[i]);
}
S = Combinar(subsoluciones);
}
return S;
}

Ejemplo Fibonacci
Fibonacci: 1 , 1 , 2 , 3 , 5, 8, 13,
F(0) = F(1) = 1
F(n) = F(n-1) + F(n-2)

F(n) se descompone en la suma de F(n-1) y

F(n-2).
Cada subproblema es resuelto de forma
independiente.

Ejemplo Fibonacci
int Fibonacci (int n) {
if (n == 0 || n == 1)
return 1;
else
return Fibonacci(n-1) + Fibonacci (n-2);
}

Inconveniente: el mismo subproblema se est

resolviendo ms de una vez!

Ejemplo Fibonacci
Fibonacci(6)

6
5

Inconveniente: el mismo subproblema se est

resolviendo ms de una vez!

Ejemplo Mergesort
Se desea ordenar una secuencia S de largo n en
orden creciente.
Estrategia Divide & Conquer:
Se divide la secuencia S en dos mitades S1 y S2 .
Se ordenan las secuencias S1 y S2 siguiendo la misma
estrategia.
Una vez ordenadas las secuencias S1 y S2 se combinan
intercalndolas en forma ordenada (Merge).

Observacin: otra posible descomposicin es

dividir la secuencia en tres o ms partes.

Ejemplo Mergesort
5

Ejemplo Mergesort
5
5

2
2

6
6

0
7

Ejemplo Mergesort
5
5
5

2
2

0
7

6
6

Ejemplo Mergesort
5
5
5
5

2
2

0
7

6
6

Ejemplo Mergesort
5
5
5

2
2

0
7

6
6

Ejemplo Mergesort
5
5
5

2
2

6
2

5
2

0
7

Ejemplo Mergesort
5
5
5

2
2

5
2

7
6

0
0

Ejemplo Mergesort
5
5
5

2
2

0
7

6
6

0
2

5
2

Ejemplo Mergesort
5
5
5

2
2

0
7

6
7

0
0

0
2

5
2

5
0

6
2

Ejemplo Mergesort
void MergeSort (int[] A, int p, int q) {
if (p < q) {
int medio = (p+q)/2;
MergeSort(A, p, medio);
MergeSort(A, medio + 1, q);
MERGE(A, p, medio, medio + 1, q);
}
}

Conclusiones y observaciones
Divide & Conquer es una tcnica conceptualmente
simple.
Los algoritmos que se ob_enen son generalmente
recursivos.
Como los subproblemas son independientes, en general
esto permite que sean resueltos en paralelo.
Por otra parte, la tcnica puede conducir a que un
mismo subproblema sea resuelto varias veces
(Fibonacci).
Finalmente, se mostr que un problema puede
descomponerse de varias formas (Mergesort).