Divisao e conquista

Divis˜

ao & Conquista

Prof. MSc. Claudia Akemi Izeki

Universidade Federal de Itajub´a - Campus Itabira

T´

ecnica de Divis˜

ao e Conquista

Considere um problema cujo tamanho seja igual a N: Divida o problema em k instˆancias disjuntas, na qual 1 <= k <= N, que correspondem a k subproblemas distintos.

Os subproblemas s˜ao resolvidos separadamente.

Encontra-se uma forma de combinar as solu¸c˜oes parciais para se obter a solu¸c˜ao que servir´a para resolver o problema

original.

T´

ecnica de Divis˜

ao e Conquista

O paradigma de dividir e conquistar envolve trˆes passos em cada n´ıvel da recurs˜ao (CORMEN et al., 2002):

1 Dividir o problema em um determinado n´umero de

subproblemas.

2 Conquistar os subproblemas, resolvendo-os recursivamente.

Por´em, se os tamanhos dos subproblemas forem pequenos o bastante, basta resolver os subproblemas de maneira direta.

3 Combinar as solu¸c˜oes dadas aos subproblemas, a fim de

An´

alise de Algoritmos de Dividir e Conquistar

Uma recorrˆencia para o tempo de execu¸c˜ao de um algoritmo de dividir e conquistar se baseia nos trˆes passos do

paradigma b´asico.

Seja T(n) o tempo de execu¸c˜ao sobre um problema de tamanho n.

Vamos supor que o problema seja dividido em a subproblemas, cada um dos quais com 1/b do tamanho do problema original. Se levarmos D(n) para dividir o problema em subproblemas e o tempo C(n) para combinar as solu¸c˜oes dadas aos

subproblemas na solu¸c˜ao para o problema original, obteremos a recorrˆencia:

Algoritmos baseados em Divis˜

ao e Conquista

Busca Bin´aria Mergesort Quicksort

Algoritmo de Busca Bin´

aria

Problema:

Encontrar um determinado elemento (chave) em um vetor ordenado de tamanho n: A1, A2, A3, ..., An.

Algoritmo de Busca Bin´

aria

Pode-se tirar proveito do fato do vetor estar ordenado: Verificar se a chave est´a na posi¸c˜ao m = bn/2c:

Se estiver, encontrou!

Se n˜ao estiver, realizar a busca bin´aria nos subvetores: Ainicio at´e Am−1, sechave < Am, ou

Am+1at´e Afimsechave > Am.

Divis˜ao: Divida o vetorA[inicio..fim] em dois subconjuntosA[inicio..m − 1]eA[m + 1..fim], sendom =n

2



.

Conquista: Verifique se o elemento desejado est´a emA[inicio..m − 1]ou emA[m + 1..fim], caso n˜ao encontre, particione o primeiro ou segundo subvetor at´e que o tamanho do subconjunto seja igual a 1.

Algoritmo de Busca Bin´

aria

int busca binaria (int a[], int elem, int inicio, int fim) {

int m;

if (inicio>fim) return -1; m = (inicio+fim)/2; if(elem == a[m]) return m; if (elem < a[m])

return busca binaria (a, elem, inicio, m-1)); else

return busca binaria (a, elem, m+1, fim); }

Desempenho do Algoritmo de Busca Bin´

aria

O algoritmo de Busca Bin´aria sempre particiona o conjunto de dados em duas partes do tamanho original, seja escolhendo a metade esquerda ou direita.

Detalhando mais o comportamento do algoritmo, pode-se chegar ao seguinte comportamento matem´atico:

T (N) = T (N/2) + 1

A constante 1 justifica-se pelo fato de sempre testar qual metade do problema ser´a considerada na pr´oxima chamada recursiva do algoritmo. Deve-se observar que para um N = 1, o custo do algoritmo ´e T (1) = 1.

Resolvendo a recorrˆ

encia da Busca Bin´

aria

T (N) = T (N 2) + 1, T (1) = 1 (1) T (N 2) = T ( N 2 2) + 1 = T ( N 4) + 1 (2) T (N) =  T (N 4) + 1  + 1 = T (N 4) + 2 (3) T (N 4) = T ( N 4 2) + 1 = T ( N 8) + 1 (4) T (N) =  T (N 8) + 1  + 2 = T (N 8) + 3 (5) T (N) = T (N 23) + 3 (6)

Resolvendo a recorrˆ

encia da Busca Bin´

aria

Considerando uma vari´avel k = 3, a equa¸c˜ao da linha (6), T (N) = T (₂N3) + 3 fica da seguinte forma:

T (N) = T (N

2k) + k (7)

Como T (1) = 1, pode-se estabelecer a seguinte rela¸c˜ao,

T (N

2k) = T (1) (8)

N

Resolvendo a recorrˆ

encia da Busca Bin´

aria

Com a rela¸c˜ao estabelecida em (10) e retornando ao item (7), tem-se o resultado: T (N) = T (2 k 2k) + k (11) T (N) = T (1) + k (12) T (N) = 1 + k (13)

Resolvendo a recorrˆ

encia da Busca Bin´

aria

Como N = 2k (10), uma forma de obtermos o valor de k ´e utilizando a fun¸c˜ao de log nesta igualdade.

log2N = log22k (14)

log2N = k × log22, log22 = 1 (15)

log2N = k × 1 (16)

k = log2N (17)

Retornando em T (N) = 1 + k = 1 + log2N.

Algoritmo Quicksort

´

E um algoritmo de ordena¸c˜ao cujo tempo de execu¸c˜ao no pior caso ´e O(N2).

Apesar deste tempo lento de execu¸c˜ao no pior caso, Quicksort ´

e, frequentemente, a melhor escolha pr´atica para a

ordena¸c˜ao devido a sua eficiˆencia no caso m´edio, cujo tempo de execu¸c˜ao ´e O(N × log2N) e os fatores constantes

impl´ıcitos s˜ao de pequeno valor.

Divis˜ao: O vetorA[p..r ]´e particionado em dois subvetoresA[p..q − 1]eA[q + 1..r ]

tais que cada elemento deA[p..q − 1]´e menor que ou igual aA[q]que, por sua vez, ´e igual ou menor a cada elemento deA[q + 1..r ]. O ´ındice q ´e calculado como parte desse procedimento de particionamento.

Conquista: Os dois vetoresA[p..q − 1]eA[q + 1..r ]s˜ao ordenados a cada chamada recursiva do Quicksort.

Combina¸c˜ao: Como os subvetores s˜ao ordenados localmente, n˜ao ´e necess´ario nenhum trabalho para combin´a-los: o vetorA[p..r ]inteiro agora est´a ordenado.

Algoritmo Quicksort

O tempo de execu¸c˜ao do algoritmo Quicksort depende se o

funcionamento ´e balanceado ou n˜ao, e isto depende dos elementos que s˜ao escolhidos para o particionamento.

Se o particionamento ´e balanceado, a execu¸c˜ao ´e r´apida. Se o particionamento ´e desbalanceado, a execu¸c˜ao do algoritmo pode ser lenta.

A fun¸c˜ao de particionamento possui complexidade Θ(N).

QUICKSORT(A, p, r) 1 se (p < r)

2 q ← PARTICIONE (A, p, r)

3 QUICKSORT (A, p, q-1) // ordena o vetor de p at´e q-1

Algoritmo PARTICIONE do Quicksort

PARTICIONE(A, p, r)

1 x ← A[r]

2 i ← p-1

3 para j← p at´e r-1 fa¸ca

4 se A[j] ≤ x ent~ao

5 i ← i+1

6 A[i] ↔ A[j]

7 A[i+1] ↔ A[r]

Desempenho do Quicksort

O tempo de execu¸c˜ao do Quicksort depende do fato de o particionamento ser ou n˜ao balanceado, que por sua vez depende de quais elementos s˜ao usados para balancear. Melhor Caso: A fun¸c˜ao de recorrˆencia T (N) ´e composta por: uma chamada para a fun¸c˜ao de parti¸c˜ao que possui

complexidade Θ(N) e duas chamadas recursivas para cada metade do vetor, ou seja, 2 × T (N/2).

T (N) = 2 × T (N/2) + N, T (0) = 1

T (N) = O(NlogN)

Pior Caso: A fun¸c˜ao de recorrˆencia, T (N) acontece quando a rotina de particionamento produz um subproblema com n − 1 elementos e um com 0 elementos. A fun¸c˜ao de parti¸c˜ao do

Desempenho do Quicksort

Caso M´edio

O tempo de execu¸c˜ao do caso m´edio est´a muito mais pr´oximo do melhor caso do que do pior caso.

Suponha, por exemplo, que o algoritmo de particionamento produza uma divis˜ao proporcional de 9 para 1, que a princ´ıpio parece bastante desequilibrada. Ent˜ao obtemos a recorrˆencia:

T (N) = T (9N/10) + T (N/10) + cN que ´e O(N logN).

Algoritmo de M´

aximo e M´ınimo de um vetor

Determinar o valor m´aximo e m´ınimo de um vetor j´a foi visto anteriormente com trˆes algoritmos. Por´em, este algoritmo ´e igual `a terceira vers˜ao vista anteriormente, mas recursiva.

ALGORITMO M´aximo M´ınimo

Divis˜ao: Divida o vetorv [inf ..sup]em dois subvetoresv [inf ..meio] ev [meio + 1..sup], ondemeio = b(inf + sup)/2c.

Conquista: S˜ao verificados e retornados os menores e maiores ele-mentos de cada subvetor v [inf ..meio] e v [meio + 1..sup] a cada chamada recursiva.

Combina¸c˜ao: S˜ao combinadas as solu¸c˜oes de cada subproblema, ou seja, como cada subproblema retorna o maior e menor elementos, na combina¸c˜ao verifica-se qual ´e o menor e o maior elementos de

Algoritmo de M´

aximo e M´ınimo de um vetor

int* maxMin4 (int v[], int inf, int sup)

{

int *maxMin = new int[2]; if (sup - inf <= 1){

if (v[inf] < v[sup]){maxMin[0] = v[sup]; maxMin[1] = v[inf];} else {maxMin[0] = v[inf]; maxMin[1] = v[sup];}

} else{

int meio = (inf+sup)/2;

maxMin = maxMin4(v, inf, meio);

int max1 = maxMin[0], min1 = maxMin[1];

maxMin = maxMin4(v, meio+1, sup);

int max2 = maxMin[0], min2 = maxMin[1];

if (max1 > max2) maxMin[0] = max1; else maxMin[0] = max2; if (min1 < min2) maxMin[1] = min1; else maxMin[1] = min2; }

return maxMin; }

Algoritmo de M´

aximo e M´ınimo de um vetor

Seja T(n) uma fun¸c˜ao de complexidade tal que T(n) ´e o n´umero de compara¸c˜oes entre os elementos de v. Logo:

A constante 2 justifica-se pelo fato das condicionais max 1 > max 2 e min1 < min2 na fase de Combina¸c˜ao da Divis˜ao e Conquista.

Bibliografia

CORMEN, Thomas H. et al. Algoritmos: teoria e pr´atica. [Introduction to algorithms, 2nd ed. ISBN 0070131511 (inglˆes)]. Tradu¸c˜ao de Vanderberg D. de Souza, Revis˜ao t´ecnica de Jussara Pimenta Matos. 13 reimpr. Rio de Janeiro: Elsevier, 2002. xvii, 916 p. Inclui bibliografia e ´ındice; il. tab. graf. org.; 28cm. ISBN 8535209263.

NAGAI, W. A. ECO014 - Complexidade de Algoritmos. Notas de Aula, 2010.

ZIVIANI, N. Projeto de Algoritmos com Implementa¸c˜oes em Java e C++, S˜ao Paulo, Brazil, Thomson Learning, ISBN 85-221-0525-1, 2007, 641 pages.