05 divisaoEConquista

Aula 10 – Técnicas de
Desenvolvimento de Algoritmos:
Divisão e Conquista
Norton Trevisan Roman

norton@usp.br
31 de março de 2020
Norton Trevisan Romannorton@usp.br Aula 10 – Técnicas de Desenvolvimento de Algoritmos: Divisão

31 de março
e Conquista
de 2020 1 / 36
Construção Incremental
No método de construção incremental, temos os

seguintes passos:

31 de março
e Conquista
de 2020 2 / 36

seguintes passos:
Inicialmente, resolvemos o problema para um subconjunto
dos elementos da entrada

31 de março
e Conquista
de 2020 2 / 36

seguintes passos:
Então adicionamos os demais elementos um a um

31 de março
e Conquista
de 2020 2 / 36

seguintes passos:
Em muitos casos, se os elementos forem adicionados em
uma ordem ruim, o algoritmo não será eficiente.

31 de março
e Conquista
de 2020 2 / 36

seguintes passos:
Em muitos casos, se os elementos forem adicionados em
uma ordem ruim, o algoritmo não será eficiente.
Exemplo:
Cálculo recursivo de n!

31 de março
e Conquista
de 2020 2 / 36
Na divisão e conquista, o problema principal é

decomposto em subproblemas menores

31 de março
e Conquista
de 2020 3 / 36

Combinando então as respostas de cada um desses
subproblemas

31 de março
e Conquista
de 2020 3 / 36

subproblemas
É mais um paradigma de projeto de algoritmos

baseado no princı́pio da indução

31 de março
e Conquista
de 2020 3 / 36

subproblemas
É mais um paradigma de projeto de algoritmos

baseado no princı́pio da indução
Informalmente, podemos dizer que o paradigma incremental
representa o projeto de algoritmos por indução fraca,
enquanto o paradigma de divisão e conquista representa o
projeto por indução forte

31 de março
e Conquista
de 2020 3 / 36
Dividir para Conquistar

31 de março
e Conquista
de 2020 4 / 36

Dividir o problema em determinado número de
subproblemas

31 de março
e Conquista
de 2020 4 / 36

subproblemas
Conquistar os subproblemas, resolvendo-os
recursivamente

31 de março
e Conquista
de 2020 4 / 36

subproblemas
recursivamente
Se o tamanho do subproblema for pequeno o bastante,
então a solução é direta (caso base)

31 de março
e Conquista
de 2020 4 / 36

subproblemas
recursivamente
Se o tamanho do subproblema for pequeno o bastante,
então a solução é direta (caso base)
Combinar as soluções fornecidas pelos

subproblemas, a fim de produzir a solução para o
problema original

31 de março
e Conquista
de 2020 4 / 36

A busca binária Entrada: arranjo arr, elemento x
recursiva utiliza essa
Se o arranjo tiver 1 elemento,
técnica? compare com x
Se x=arr[meio], meio é o ı́ndice

do elemento procurado
Se x<arr[meio], repete a busca
no subarranjo de 0 a meio-1
Sen~
ao
repete a busca no subarranjo
de meio+1 ao fim de arr

31 de março
e Conquista
de 2020 5 / 36

Dividir: Se x=arr[meio], meio é o ı́ndice

Divide o problema em do elemento procurado
sub-problemas?
Sen~
ao

31 de março
e Conquista
de 2020 5 / 36


sub-problemas?
Sen~
ao

31 de março
e Conquista
de 2020 5 / 36


sub-problemas?
Sen~
ao
Conquistar: repete a busca no subarranjo
Resolve os sub-problemas de meio+1 ao fim de arr
recursivamente?

31 de março
e Conquista
de 2020 5 / 36


sub-problemas?
Sen~
ao
Conquistar: repete a busca no subarranjo
Resolve os sub-problemas de meio+1 ao fim de arr
recursivamente?

31 de março
e Conquista
de 2020 5 / 36

Combinar: Entrada: arranjo arr, elemento x
Forma a solução final a
partir da combinação das Se o arranjo tiver 1 elemento,
compare com x
soluções dos
sub-problemas? Se x=arr[meio], meio é o ı́ndice
Sen~
ao

31 de março
e Conquista
de 2020 6 / 36

compare com x
soluções dos
Sen~
ao

31 de março
e Conquista
de 2020 6 / 36

compare com x
soluções dos
Nesse caso, a etapa de do elemento procurado
combinar tem custo zero, no subarranjo de 0 a meio-1
pois o resultado do Sen~
ao
subproblema já é o repete a busca no subarranjo
resultado do problema de meio+1 ao fim de arr
maior

31 de março
e Conquista
de 2020 6 / 36
Ex: Exponenciação
Solução 1: Indução Fraca

Calcule an para todo real a e inteiro n ≥ 0

31 de março
e Conquista
de 2020 7 / 36

Caso base:

31 de março
e Conquista
de 2020 7 / 36

Caso base:
n = 0 ⇒ a0 = 1

31 de março
e Conquista
de 2020 7 / 36

Caso base:
n = 0 ⇒ a0 = 1
Hipótese de indução:

31 de março
e Conquista
de 2020 7 / 36

Caso base:
n = 0 ⇒ a0 = 1
Para qualquer inteiro n > 0 e real a sei calcular an−1

31 de março
e Conquista
de 2020 7 / 36

Caso base:
n = 0 ⇒ a0 = 1
Passo:

31 de março
e Conquista
de 2020 7 / 36

Caso base:
n = 0 ⇒ a0 = 1
Passo:
an = a × an−1 . Pela H.I., sei calcular an−1 , logo sei calcular
an

31 de março
e Conquista
de 2020 7 / 36

double exp(double a, int n)
Então... {
if (n == 0) return(1);
return(a * exp(a,n-1));
}

31 de março
e Conquista
de 2020 8 / 36

Então... {
E qual a complexidade if (n == 0) return(1);
dessa solução? }
(
se n = 0
T (n) =
para n ≥ 1

31 de março
e Conquista
de 2020 8 / 36

Então... {
(
O(1) se n = 0
T (n) =
para n ≥ 1

31 de março
e Conquista
de 2020 8 / 36

Então... {
(
O(1) se n = 0
T (n) =
T (n − 1) para n ≥ 1

31 de março
e Conquista
de 2020 8 / 36

Então... {
(
O(1) se n = 0
T (n) =
T (n − 1) + O(1) para n ≥ 1

31 de março
e Conquista
de 2020 8 / 36

E...
T (n) = T (n − 1) + O(1)
{
}

31 de março
e Conquista
de 2020 9 / 36

E...
T (n) = T (n − 1) + O(1)
{
= O(1) + ni=1 O(1)
P
}

31 de março
e Conquista
de 2020 9 / 36

E...
T (n) = T (n − 1) + O(1)
{
= O(1) + ni=1 O(1)
P
= O(1) + nO(1) return(a * exp(a,n-1));
}

31 de março
e Conquista
de 2020 9 / 36

E...
T (n) = T (n − 1) + O(1)
{
= O(1) + ni=1 O(1)
P
= O(1) + nO(1) return(a * exp(a,n-1));
}
= O(n)

31 de março
e Conquista
de 2020 9 / 36
Solução 2: Indução Forte
Norton Trevisan Romannorton@usp.br Aula 10 – Técnicas de Desenvolvimento de Algoritmos: 31

Divisão
de março
e Conquista
de 2020 10 / 36
Caso base:

Divisão
de março
e Conquista
de 2020 10 / 36
Caso base:
n = 0 ⇒ a0 = 1

Divisão
de março
e Conquista
de 2020 10 / 36
Caso base:
n = 0 ⇒ a0 = 1

Divisão
de março
e Conquista
de 2020 10 / 36
Caso base:
n = 0 ⇒ a0 = 1
Para qualquer inteiro n ≥ 0 e real a sei calcular
ak , 0 ≤ k ≤ n − 1

Divisão
de março
e Conquista
de 2020 10 / 36
Caso base:
n = 0 ⇒ a0 = 1
ak , 0 ≤ k ≤ n − 1
Passo:

Divisão
de março
e Conquista
de 2020 10 / 36
Caso base:
n = 0 ⇒ a0 = 1
ak , 0 ≤ k ≤ n − 1
Passo:
Vamos calcular an . Como ficaria o cálculo de an se
n n
soubéssemos a 2 (de fato, ab 2 c )?

Divisão
de março
e Conquista
de 2020 10 / 36

Passo:

Divisão
de março
e Conquista
de 2020 11 / 36

Passo:
Podemos escrever an como
( n
(ab 2 c )2 , se n par
an =

Divisão
de março
e Conquista
de 2020 11 / 36

Passo:
( n
an = n
a × (ab 2 c )2 se n ı́mpar

Divisão
de março
e Conquista
de 2020 11 / 36

Passo:
( n
an = n
a × (ab 2 c )2 se n ı́mpar
n
Pela H.I., sei calcular ab 2 c , então sei calcular an

Divisão
de março
e Conquista
de 2020 11 / 36
double exp(double a,int n){
if (n == 0) return 1;
else {
double aux = exp(a,n/2);
double an = aux * aux;
if (n % 2 == 1)
an = an * a;
return an;
}
}

Divisão
de março
e Conquista
de 2020 12 / 36
else {
E qual a complexidade double an = aux * aux;
if (n % 2 == 1)
disso? an = an * a;
return an;
}
}
(
se n = 0
T (n) =
para n ≥ 1

Divisão
de março
e Conquista
de 2020 12 / 36
else {
if (n % 2 == 1)
disso? an = an * a;
return an;
}
}
(
O(1) se n = 0
T (n) =
para n ≥ 1

Divisão
de março
e Conquista
de 2020 12 / 36
else {
if (n % 2 == 1)
disso? an = an * a;
return an;
}
}
(
O(1) se n = 0
T (n) = n
T(2) para n ≥ 1

Divisão
de março
e Conquista
de 2020 12 / 36
else {
if (n % 2 == 1)
disso? an = an * a;
return an;
}
}
(
O(1) se n = 0
T (n) = n
T ( 2 ) + O(1) para n ≥ 1

Divisão
de março
e Conquista
de 2020 12 / 36

Mas T (n) = T ( n2 ) + O(1) é também a
complexidade da busca binária

Divisão
de março
e Conquista
de 2020 13 / 36

Que já vimos ser T (n) = O(log2 (n))

Divisão
de março
e Conquista
de 2020 13 / 36

Então, em sua versão incremental, a exponenciação
é O(n), enquanto que em sua versão por divisão e
conquista é O(log2 (n))

Divisão
de março
e Conquista
de 2020 13 / 36

Lembrando que n > log2 (n), para n ≥ 1.

Divisão
de março
e Conquista
de 2020 13 / 36

Lembrando que n > log2 (n), para n ≥ 1.
Mas isso, claro, vai depender das constantes multiplicativas

Divisão
de março
e Conquista
de 2020 13 / 36
Ex: Máximo e Mı́nimo

Dado um arranjo S de n ≥ 2 números reais,
determine o maior e o menor elemento de S

Divisão
de março
e Conquista
de 2020 14 / 36

Caso base:

Divisão
de março
e Conquista
de 2020 14 / 36

Caso base:
n = 2: Compare um com o outro e veja qual o maior

Divisão
de março
e Conquista
de 2020 14 / 36

Caso base:

Divisão
de março
e Conquista
de 2020 14 / 36

Caso base:
Sei o maior e o menor dentre os n − 1 primeiros elementos
do arranjo

Divisão
de março
e Conquista
de 2020 14 / 36

Passo:

Divisão
de março
e Conquista
de 2020 15 / 36

Passo:
Pela H.I., consigo calcular o maior e o menor entre os n − 1
primeiros elementos de S

Divisão
de março
e Conquista
de 2020 15 / 36

Passo:
Se o n-ésimo elemento for maior que o maior em n − 1,
então ele é o maior de todos. Senão, o resultado de n − 1 é
o maior

Divisão
de março
e Conquista
de 2020 15 / 36

Passo:
Se o n-ésimo elemento for maior que o maior em n − 1,
então ele é o maior de todos. Senão, o resultado de n − 1 é
o maior
Se o n-ésimo elemento for menor que o menor em n − 1,
então ele é o menor de todos. Senão, o resultado de n − 1 é
o menor

Divisão
de março
e Conquista
de 2020 15 / 36
double[] mM(double s[], else {
int n) { resp = mM(s,n-1);
double[] resp; if (s[n-1] > resp[0])
if (n==2) { resp[0] = s[n-1];
resp = new double[2]; if (s[n-1] < resp[1])
if (s[0]>s[1]) { resp[1] = s[n-1];
resp[0] = s[0]; }
resp[1] = s[1]; return(resp);
} }
else {
resp[0] = s[1];
resp[1] = s[0];
}
}
Divisão
de março
e Conquista
de 2020 16 / 36
double[] mM(double s[], else {
int n) { resp = mM(s,n-1);
double[] resp; if (s[n-1] > resp[0])
if (n==2) { resp[0] = s[n-1];
resp = new double[2]; if (s[n-1] < resp[1])
if (s[0]>s[1]) { resp[1] = s[n-1];
resp[0] = s[0]; }
resp[1] = s[1]; return(resp);
} }
else {
resp[0] = s[1]; E qual a complexidade
resp[1] = s[0]; disso?
}
}
Divisão
de março
e Conquista
de 2020 16 / 36
double[] mM(double s[], int n) { else {
double[] resp; resp = mM(s,n-1);
if (n==2) { if (s[n-1] > resp[0])
resp = new double[2]; resp[0] = s[n-1];
if (s[0]>s[1]) { if (s[n-1] < resp[1])
resp[0] = s[0]; resp[1] = s[n-1];
resp[1] = s[1]; }
} else { return(resp);
resp[0] = s[1]; }
resp[1] = s[0];
}
} (
se n = 2
T (n) =
se n > 2

Divisão
de março
e Conquista
de 2020 17 / 36
if (n==2) { if (s[n-1] > resp[0])
if (s[0]>s[1]) { if (s[n-1] < resp[1])
resp[0] = s[0]; resp[1] = s[n-1];
resp[1] = s[1]; }
resp[0] = s[1]; }
resp[1] = s[0];
}
} (
O(1) se n = 2
T (n) =
se n > 2

Divisão
de março
e Conquista
de 2020 17 / 36
if (n==2) { if (s[n-1] > resp[0])
if (s[0]>s[1]) { if (s[n-1] < resp[1])
resp[0] = s[0]; resp[1] = s[n-1];
resp[1] = s[1]; }
resp[0] = s[1]; }
resp[1] = s[0];
}
} (
O(1) se n = 2
T (n) =
T (n − 1) se n > 2

Divisão
de março
e Conquista
de 2020 17 / 36
if (n==2) { if (s[n-1] > resp[0])
if (s[0]>s[1]) { if (s[n-1] < resp[1])
resp[0] = s[0]; resp[1] = s[n-1];
resp[1] = s[1]; }
resp[0] = s[1]; }
resp[1] = s[0];
}
} (
O(1) se n = 2
T (n) =
T (n − 1) + O(1) se n > 2

Divisão
de março
e Conquista
de 2020 17 / 36
if (n==2) { if (s[n-1] > resp[0])
if (s[0]>s[1]) { if (s[n-1] < resp[1])
resp[0] = s[0]; resp[1] = s[n-1];
resp[1] = s[1]; }
resp[0] = s[1]; }
resp[1] = s[0];
}
}
E T (n) ∈ O(n) (idem à busca sequencial)

Divisão
de março
e Conquista
de 2020 18 / 36


Divisão
de março
e Conquista
de 2020 19 / 36

Caso base:

Divisão
de março
e Conquista
de 2020 19 / 36

Caso base:

Divisão
de março
e Conquista
de 2020 19 / 36

Caso base:

Divisão
de março
e Conquista
de 2020 19 / 36

Caso base:
Sei encontrar o maior e o menor elemento em sub-arranjos
de tamanho 2 ≤ k ≤ n − 1

Divisão
de março
e Conquista
de 2020 19 / 36

Passo:

Divisão
de março
e Conquista
de 2020 20 / 36

Passo:
Vejamos para um arranjo de n elementos. Pela H.I., sei o
menor o maior elemento em sub-arranjos de tamanho b n2 c

Divisão
de março
e Conquista
de 2020 20 / 36

Passo:
Então, se n for par, o maior elemento será o maior dentre as
respostas de b n2 c que correspondem às 2 metades do arranjo.
O mesmo vale para o menor.

Divisão
de março
e Conquista
de 2020 20 / 36

Passo:
Então, se n for par, o maior elemento será o maior dentre as
respostas de b n2 c que correspondem às 2 metades do arranjo.
O mesmo vale para o menor.
Se n for ı́mpar, o maior será o maior dentre S[n] e o maior
dos dois sub-arranjos de b n2 c, que correspondem às 2
metades do arranjo de n − 1 elementos restante ao
retirarmos S[n]. O mesmo vale para o menor.

Divisão
de março
e Conquista
de 2020 20 / 36

E qual a complexidade desse algoritmo?

Divisão
de março
e Conquista
de 2020 21 / 36

(
O(1) se n = 2
T (n) = n
2T ( 2 ) + O(1) se n > 2

Divisão
de março
e Conquista
de 2020 21 / 36

(
O(1) se n = 2
T (n) = n
2T ( 2 ) + O(1) se n > 2
Temos então que T (n) ∈ O(n)

Divisão
de março
e Conquista
de 2020 21 / 36

(
O(1) se n = 2
T (n) = n
2T ( 2 ) + O(1) se n > 2

A demonstração fica por sua conta

Divisão
de março
e Conquista
de 2020 21 / 36

(
O(1) se n = 2
T (n) = n
2T ( 2 ) + O(1) se n > 2

Não houve melhora em relação à versão anterior

Divisão
de março
e Conquista
de 2020 21 / 36

(
O(1) se n = 2
T (n) = n
2T ( 2 ) + O(1) se n > 2

Não houve melhora em relação à versão anterior

Você esperaria mesmo ser menor que O(n)?

Divisão
de março
e Conquista
de 2020 21 / 36
A complexidade de tempo de algoritmos divisão e

conquista, para uma entrada de tamanho n, é:

Divisão
de março
e Conquista
de 2020 22 / 36

T (n) = Dividir (n) + Conquistar (n) + Combinar (n)

Divisão
de março
e Conquista
de 2020 22 / 36

Para entradas pequenas, isto é, para n ≤ c, c pequeno,
podemos assumir que T (n) ∈ Θ(1) (caso base)

Divisão
de março
e Conquista
de 2020 22 / 36

Vamos supor que o problema seja dividido em a

subproblemas, cada um com b1 do tamanho original

Divisão
de março
e Conquista
de 2020 22 / 36


Como fica a “Conquista” C (n)?

Divisão
de março
e Conquista
de 2020 22 / 36


Como fica a “Conquista” C (n)?
n
C (n) = aT
b

Divisão
de março
e Conquista
de 2020 22 / 36
Se levamos D(n) para dividir o problema em

subproblemas e C (n) para combinar suas soluções,
então tem-se a recorrência T (n):

Divisão
de março
e Conquista
de 2020 23 / 36
Se levamos D(n) para dividir o problema em

subproblemas e C (n) para combinar suas soluções,
então tem-se a recorrência T (n):
(
Θ(1) se n ≤ c
T (n) =
aT (n/b) + D(n) + C (n) caso contrário

Divisão
de março
e Conquista
de 2020 23 / 36
A expressão geral de recorrência de um algoritmo de

divisão e conquista é então
n
T (n) = aT ( ) + f (n)
b

Divisão
de março
e Conquista
de 2020 24 / 36

n
T (n) = aT ( ) + f (n)
b
Onde:

Divisão
de março
e Conquista
de 2020 24 / 36

n
T (n) = aT ( ) + f (n)
b
Onde:
a representa o número de subproblemas obtidos na divisão

Divisão
de março
e Conquista
de 2020 24 / 36

n
T (n) = aT ( ) + f (n)
b
Onde:
n
b
representa seu tamanho

Divisão
de março
e Conquista
de 2020 24 / 36

n
T (n) = aT ( ) + f (n)
b
Onde:
n
b
f (n) é a função que dá a complexidade das etapas de divisão
e combinação

Divisão
de março
e Conquista
de 2020 24 / 36

n
T (n) = aT ( ) + f (n)
b
Onde:
n
b
f (n) é a função que dá a complexidade das etapas de divisão
e combinação
f (n) = D(n) + C (n)

Divisão
de março
e Conquista
de 2020 24 / 36
Relação:
n
T (n) = aT ( ) + f (n)
b

Divisão
de março
e Conquista
de 2020 25 / 36
Relação:
n
T (n) = aT ( ) + f (n)
b
Haveria um meio mais
fácil de calcularmos a
complexidade desse tipo
de expressão?

Divisão
de março
e Conquista
de 2020 25 / 36
O Teorema Mestre
Relação:
n
T (n) = aT ( ) + f (n)
b
Haveria um meio mais
fácil de calcularmos a
complexidade desse tipo
de expressão?
Kung Fu Panda - DreamWorks Animation
R

Divisão
de março
e Conquista
de 2020 25 / 36
Teorema Mestre
Sejam a ≥ 1 e b > 1 constantes. Seja f (n) uma função, e seja
T (n) definida para os inteiros não negativos pela relação de
recorrência
T (n) = aT (n/b) + f (n)
Então T (n) pode ser limitada assintoticamente da seguinte
maneira:
1 Se f (n) ∈ O(nlogb a− ), para alguma constante > 0, então
T (n) ∈ Θ(nlogb a )
2 Se f (n) ∈ Θ(nlogb a ), então T (n) ∈ Θ(nlogb a log n)
3 Se f (n) ∈ Ω(nlogb a+ ), para alguma constante > 0, e se
af (n/b) ≤ cf (n), para alguma constante c < 1 e todo n
suficientemente grande, então T (n) ∈ Θ(f (n))

Divisão
de março
e Conquista
de 2020 26 / 36
Teorema Mestre: Exemplo
T (n) = 9T (n/3) + n 1 Se f (n) ∈ O(nlogb a− ), para alguma
constante > 0, então T (n) ∈ Θ(nlogb a )
2 Se f (n) ∈ Θ(nlogb a ), então
T (n) ∈ Θ(nlogb a log n)
3 Se f (n) ∈ Ω(nlogb a+ ), para alguma
constante > 0, e se af (n/b) ≤ cf (n),
para alguma constante c < 1 e todo n
suficientemente grande, então
T (n) ∈ Θ(f (n))

Divisão
de março
e Conquista
de 2020 27 / 36
a = 9, b = 3, f (n) = n
T (n) ∈ Θ(f (n))

Divisão
de março
e Conquista
de 2020 27 / 36
a = 9, b = 3, f (n) = n
Testamos as opções,
Se f (n) ∈ Ω(nlogb a+ ), para alguma
iniciando pela 2a 3
T (n) ∈ Θ(f (n))

Divisão
de março
e Conquista
de 2020 27 / 36
a = 9, b = 3, f (n) = n
iniciando pela 2a 3
Note que nlog3 9 = n2 suficientemente grande, então
aparece em todas as 3 T (n) ∈ Θ(f (n))
alternativas

Divisão
de março
e Conquista
de 2020 27 / 36
a = 9, b = 3, f (n) = n
iniciando pela 2a 3
alternativas
Verificamos se n ∈ Θ(nlog3 9 ), ou seja, se n ∈ Θ(n2 )

Divisão
de março
e Conquista
de 2020 27 / 36
a = 9, b = 3, f (n) = n
iniciando pela 2a 3
alternativas
Verificamos se n ∈ Θ(nlog3 9 ), ou seja, se n ∈ Θ(n2 )
Isto não é verdade e, já que n2 ’domina’ n, devemos testar a
1a opção que é a que diminui o expoente de n (O(nlogb a− ))

Divisão
de março
e Conquista
de 2020 27 / 36

1 Se f (n) ∈ O(nlogb a− ), para alguma
T (n) = 9T (n/3) + n
a = 9, b = 3, f (n) = n T (n) ∈ Θ(nlogb a log n)
a
Testamos então a 1 constante > 0, e se af (n/b) ≤ cf (n),
opção suficientemente grande, então
T (n) ∈ Θ(f (n))

Divisão
de março
e Conquista
de 2020 28 / 36

T (n) = 9T (n/3) + n
a
T (n) ∈ Θ(f (n))
Temos que n ∈ O(nlog3 9− ), para = 1 (Caso 1)

Divisão
de março
e Conquista
de 2020 28 / 36

T (n) = 9T (n/3) + n
a
T (n) ∈ Θ(f (n))

Ou seja, n ∈ O(n2−1 ) = O(n)

Divisão
de março
e Conquista
de 2020 28 / 36

T (n) = 9T (n/3) + n
a
T (n) ∈ Θ(f (n))

Ou seja, n ∈ O(n2−1 ) = O(n)
Então, pelo teorema, T (n) ∈ Θ(n2 )

Divisão
de março
e Conquista
de 2020 28 / 36

T (n) = T (2n/3) + 1
T (n) ∈ Θ(f (n))

Divisão
de março
e Conquista
de 2020 29 / 36

T (n) = T (2n/3) + 1
a = 1, b = 32 , f (n) = 1 constante > 0, então T (n) ∈ Θ(nlogb a )
T (n) ∈ Θ(f (n))

Divisão
de março
e Conquista
de 2020 29 / 36

T (n) = T (2n/3) + 1
Testamos as opções, T (n) ∈ Θ(nlogb a log n)
iniciando pela 2a : 3 Se f (n) ∈ Ω(nlogb a+ ), para alguma
T (n) ∈ Θ(f (n))

Divisão
de março
e Conquista
de 2020 29 / 36

T (n) = T (2n/3) + 1
nlog3/2 1 = n0 = 1 para alguma constante c < 1 e todo n
T (n) ∈ Θ(f (n))

Divisão
de março
e Conquista
de 2020 29 / 36

T (n) = T (2n/3) + 1
Pelo Caso 2, temos que T (n) ∈ Θ(f (n))
1 ∈ Θ(n0 ) ⇒ 1 ∈ Θ(1)

Divisão
de março
e Conquista
de 2020 29 / 36

T (n) = T (2n/3) + 1
Pelo Caso 2, temos que T (n) ∈ Θ(f (n))
1 ∈ Θ(n0 ) ⇒ 1 ∈ Θ(1)
Então T (n) ∈ Θ(n0 log n) ⇒ T (n) ∈ Θ(log n)

Divisão
de março
e Conquista
de 2020 29 / 36
T (n) = 3T (n/4)+ 1 Se f (n) ∈ O(nlogb a− ), para alguma
n × log n
T (n) ∈ Θ(f (n))

Divisão
de março
e Conquista
de 2020 30 / 36
n × log n
a = 3, b = 4, f (n) = T (n) ∈ Θ(nlogb a log n)
n × log n 3 Se f (n) ∈ Ω(nlogb a+ ), para alguma
T (n) ∈ Θ(f (n))

Divisão
de março
e Conquista
de 2020 30 / 36
n × log n
Testamos a 2a opção: para alguma constante c < 1 e todo n
T (n) ∈ Θ(f (n))

Divisão
de março
e Conquista
de 2020 30 / 36
n × log n
T (n) ∈ Θ(f (n))
f (n) ∈ Θ(nlogb a )?

Divisão
de março
e Conquista
de 2020 30 / 36
n × log n
T (n) ∈ Θ(f (n))
Se for, então n × log n ∈ Θ(nlog4 3 ) ∈ Θ(n0,793 )

Divisão
de março
e Conquista
de 2020 30 / 36
n × log n
T (n) ∈ Θ(f (n))
Não, pois n × log n ∈ ω(n0,793 )

Divisão
de março
e Conquista
de 2020 30 / 36
n × log n
T (n) ∈ Θ(f (n))
Não, pois n × log n ∈ ω(n0,793 )
Devemos testar a 3a opção, que aumenta o expoente de n
(f (n) ∈ Ω(nlogb a+ ))
Divisão
de março
e Conquista
de 2020 30 / 36

n × log n
T (n) ∈ Θ(f (n))

Divisão
de março
e Conquista
de 2020 31 / 36

n × log n
T (n) ∈ Θ(f (n))
f (n) ∈ Ω(nlogb a+ )?

Divisão
de março
e Conquista
de 2020 31 / 36

n × log n
T (n) ∈ Θ(f (n))
Se for, então n × log n ∈ Ω(nlog4 3+ ) ∈ Ω(n0,793+ ), > 0

Divisão
de março
e Conquista
de 2020 31 / 36

n × log n
T (n) ∈ Θ(f (n))
Se for, então n × log n ∈ Ω(nlog4 3+ ) ∈ Ω(n0,793+ ), > 0
Fazendo ≈ 0, 2, temos que n × log n ∈ Ω(n1 )

Divisão
de março
e Conquista
de 2020 31 / 36
n × log n
T (n) ∈ Θ(f (n))
E af (n/b) ≤ cf (n)?

Divisão
de março
e Conquista
de 2020 32 / 36
n × log n
T (n) ∈ Θ(f (n))
⇒ 3 n4 log n4 ≤ cn log n?

Divisão
de março
e Conquista
de 2020 32 / 36
n × log n
T (n) ∈ Θ(f (n))
⇒ 3 n4 (log n − log 4) ≤ cn log n.

Divisão
de março
e Conquista
de 2020 32 / 36
n × log n
T (n) ∈ Θ(f (n))
⇒ 3 n4 (log n − log 4) ≤ cn log n. Para c = 3
4
isso é verdadeiro

Divisão
de março
e Conquista
de 2020 32 / 36
n × log n
T (n) ∈ Θ(f (n))
⇒ 3 n4 (log n − log 4) ≤ cn log n. Para c = 3
4
isso é verdadeiro
Portanto T (n) ∈ Θ(n log n)

Divisão
de março
e Conquista
de 2020 32 / 36
Exemplos onde o Teorema Mestre se aplica

T (n) = 4T (n/2) + n log n, T (1) = 1
Caso 1

Divisão
de março
e Conquista
de 2020 33 / 36

T (n) = 4T (n/2) + n log n, T (1) = 1
Caso 1
T (n) = 2T (n/2) + n, T (1) = 1

Caso 2

Divisão
de março
e Conquista
de 2020 33 / 36

T (n) = 4T (n/2) + n log n, T (1) = 1
Caso 1
T (n) = 2T (n/2) + n, T (1) = 1

Caso 2
T (n) = T (n/2) + n log n, T (1) = 1

Caso 3

Divisão
de março
e Conquista
de 2020 33 / 36
Exemplos onde o Teorema Mestre não se aplica

T (n) = T (n − 1) + n log n, T (1) = 1

Divisão
de março
e Conquista
de 2020 34 / 36

T (n) = T (n − 1) + n log n, T (1) = 1
T (n) = T (n − a) + T (a) + n, T (b) = 1 (para
inteiros a ≥ 1, b ≤ a)

Divisão
de março
e Conquista
de 2020 34 / 36

T (n) = T (n − 1) + n log n, T (1) = 1
T (n) = T (n − a) + T (a) + n, T (b) = 1 (para
T (n) = T (αn) + T ((1 − α)n) + n, T (1) = 1 (para
0 < α < 1)

Divisão
de março
e Conquista
de 2020 34 / 36

T (n) = T (n − 1) + n log n, T (1) = 1
T (n) = T (n − a) + T (a) + n, T (b) = 1 (para
T (n) = T (αn) + T ((1 − α)n) + n, T (1) = 1 (para
0 < α < 1)
T (n) = T (n − 1) + log n, T (1) = 1

Divisão
de março
e Conquista
de 2020 34 / 36

T (n) = T (n − 1) + n log n, T (1) = 1
T (n) = T (n − a) + T (a) + n, T (b) = 1 (para
T (n) = T (αn) + T ((1 − α)n) + n, T (1) = 1 (para
0 < α < 1)
T (n) = T (n − 1) + log n, T (1) = 1
T (n) = 2T (n/2) + n log n, T (1) = 1

Divisão
de março
e Conquista
de 2020 34 / 36
Teorema Mestre: Observação

Trabalhamos até então com relações de recorrência
do tipo
T (n) = aT (n/b) + f (n)

Divisão
de março
e Conquista
de 2020 35 / 36

do tipo
T (n) = aT (n/b) + f (n)
Contudo, a relação não está bem definida, pois n/b
pode não ser inteiro

Divisão
de março
e Conquista
de 2020 35 / 36

do tipo
T (n) = aT (n/b) + f (n)
De fato, relaxamos a definição, mas o correto seria
usar T (dn/be) ou T (bn/bc)

Divisão
de março
e Conquista
de 2020 35 / 36

do tipo
T (n) = aT (n/b) + f (n)
De fato, relaxamos a definição, mas o correto seria
usar T (dn/be) ou T (bn/bc)
Não importa qual usar, pois isso não afeta o comportamento
assintótico da recorrência

Divisão
de março
e Conquista
de 2020 35 / 36
Referências
Ziviani, Nivio. Projeto de Algoritmos: com implementações

em Java e C++. Cengage. 2007.
Cormen, Thomas H., Leiserson, Charles E., Rivest, Ronald L.,

Stein, Clifford. Introduction to Algorithms. 2a ed. MIT Press,
2001.
Gersting, Judith L. Fundamentos Matemáticos para a Ciência

da Computação. 3a ed. LTC. 1993.

Divisão
de março
e Conquista
de 2020 36 / 36

05 divisaoEConquista

Enviado por

Dados do documento

Descrição original:

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

05 divisaoEConquista

Enviado por

Direitos autorais:

Formatos disponíveis

Aula 10 – Técnicas de

Norton Trevisan Roman

Norton Trevisan Romannorton@usp.br Aula 10 – Técnicas de Desenvolvimento de Algoritmos: Divisão

No método de construção incremental, temos os

Norton Trevisan Romannorton@usp.br Aula 10 – Técnicas de Desenvolvimento de Algoritmos: Divisão

No método de construção incremental, temos os

Norton Trevisan Romannorton@usp.br Aula 10 – Técnicas de Desenvolvimento de Algoritmos: Divisão

No método de construção incremental, temos os

Norton Trevisan Romannorton@usp.br Aula 10 – Técnicas de Desenvolvimento de Algoritmos: Divisão

No método de construção incremental, temos os

Norton Trevisan Romannorton@usp.br Aula 10 – Técnicas de Desenvolvimento de Algoritmos: Divisão

No método de construção incremental, temos os

Norton Trevisan Romannorton@usp.br Aula 10 – Técnicas de Desenvolvimento de Algoritmos: Divisão

Na divisão e conquista, o problema principal é

Norton Trevisan Romannorton@usp.br Aula 10 – Técnicas de Desenvolvimento de Algoritmos: Divisão

Na divisão e conquista, o problema principal é

Norton Trevisan Romannorton@usp.br Aula 10 – Técnicas de Desenvolvimento de Algoritmos: Divisão

Na divisão e conquista, o problema principal é

É mais um paradigma de projeto de algoritmos

Norton Trevisan Romannorton@usp.br Aula 10 – Técnicas de Desenvolvimento de Algoritmos: Divisão

Na divisão e conquista, o problema principal é

É mais um paradigma de projeto de algoritmos

Norton Trevisan Romannorton@usp.br Aula 10 – Técnicas de Desenvolvimento de Algoritmos: Divisão

Dividir para Conquistar

Norton Trevisan Romannorton@usp.br Aula 10 – Técnicas de Desenvolvimento de Algoritmos: Divisão

Dividir para Conquistar

Norton Trevisan Romannorton@usp.br Aula 10 – Técnicas de Desenvolvimento de Algoritmos: Divisão

Dividir para Conquistar

Norton Trevisan Romannorton@usp.br Aula 10 – Técnicas de Desenvolvimento de Algoritmos: Divisão

Dividir para Conquistar

Norton Trevisan Romannorton@usp.br Aula 10 – Técnicas de Desenvolvimento de Algoritmos: Divisão

Dividir para Conquistar

Combinar as soluções fornecidas pelos

Norton Trevisan Romannorton@usp.br Aula 10 – Técnicas de Desenvolvimento de Algoritmos: Divisão

Dividir para Conquistar

Se x=arr[meio], meio é o ı́ndice

Norton Trevisan Romannorton@usp.br Aula 10 – Técnicas de Desenvolvimento de Algoritmos: Divisão

Dividir para Conquistar

Dividir: Se x=arr[meio], meio é o ı́ndice

Norton Trevisan Romannorton@usp.br Aula 10 – Técnicas de Desenvolvimento de Algoritmos: Divisão

Dividir para Conquistar

Dividir: Se x=arr[meio], meio é o ı́ndice

Norton Trevisan Romannorton@usp.br Aula 10 – Técnicas de Desenvolvimento de Algoritmos: Divisão

Dividir para Conquistar

Dividir: Se x=arr[meio], meio é o ı́ndice

Norton Trevisan Romannorton@usp.br Aula 10 – Técnicas de Desenvolvimento de Algoritmos: Divisão

Dividir para Conquistar

Dividir: Se x=arr[meio], meio é o ı́ndice

Norton Trevisan Romannorton@usp.br Aula 10 – Técnicas de Desenvolvimento de Algoritmos: Divisão

Dividir para Conquistar

Norton Trevisan Romannorton@usp.br Aula 10 – Técnicas de Desenvolvimento de Algoritmos: Divisão

Dividir para Conquistar

Norton Trevisan Romannorton@usp.br Aula 10 – Técnicas de Desenvolvimento de Algoritmos: Divisão

Dividir para Conquistar

Norton Trevisan Romannorton@usp.br Aula 10 – Técnicas de Desenvolvimento de Algoritmos: Divisão

Solução 1: Indução Fraca

Norton Trevisan Romannorton@usp.br Aula 10 – Técnicas de Desenvolvimento de Algoritmos: Divisão

Solução 1: Indução Fraca

Norton Trevisan Romannorton@usp.br Aula 10 – Técnicas de Desenvolvimento de Algoritmos: Divisão

Solução 1: Indução Fraca

Norton Trevisan Romannorton@usp.br Aula 10 – Técnicas de Desenvolvimento de Algoritmos: Divisão

Solução 1: Indução Fraca