Estruturas de Dados 2

Recorrências

IF64C – Estruturas de Dados 2 – Engenharia da Computação – Prof. João Alberto Fabro - Slide 1/31
 Recorrências
● Análise da Eficiência de Algoritmos:
● Velocidade de Execução;

● Análise Matemática:
● Algoritmos não-recursivo;
● Algoritmos recursivos (recorrências);

IF64C – Estruturas de Dados 2 – Engenharia da Computação – Prof. João Alberto Fabro - Slide 2/31
 Recorrências
●
Capítulo 4 – CLRS(Cormem, 2nd Edição, 2001)
● Introdução

● Exemplo de Análise de Recorrência: MergeSort

●
Conclusão: T(n) = Θ ( n*lg(n) )
● Mas como chegar a esta conclusão? Três métodos:

● Método da Substituição
● Método da Árvore de Recursão
● Método Master

IF64C – Estruturas de Dados 2 – Engenharia da Computação – Prof. João Alberto Fabro - Slide 3/31
 Recorrências - Método da Substituição
● Basta “chutar” uma resposta (limite assintótico)...
... e em seguida, provar por indução que funciona!
● Por exemplo, suponha a recursão da forma:

T(n) = 2 T(n/2) + n
●
Supondo que a solução seja T(n) = O ( n*lg(n) )
● Agora, como provamos que isto é verdade?

●
Basta provar que T(n) ≤ c * n * lg (n) para algum c > 0.
●
Iniciamos assumindo que a fórmula é verdade para n/2:
T(n/2 ) ≤ c * n/2 * lg (n/2)
●Então verificamos se a recorrência pode ser provada!!!

IF64C – Estruturas de Dados 2 – Engenharia da Computação – Prof. João Alberto Fabro - Slide 4/31
 Recorrências - Método da Substituição
● Método da Substituição
Agora substituímos esta fórmula na recorrência:
●

T(n) ≤ 2(c ⌊n/2⌋ lg(⌊n/2⌋)) + n

≤ c n lg(n/2) + n
= c n lg n – c n lg 2 + n
= c n lg n – c n + n
≤ c n lg n,
para qualquer c ≥ 1

Agora basta provar a Base da Indução:pela definição, T(1)=1.

Calculando pelo nosso “chute”, T(1) ≤ c *1* lg 1....
.....mas lg 1 = 0, então nenhuma constante c satisfaz.......

IF64C – Estruturas de Dados 2 – Engenharia da Computação – Prof. João Alberto Fabro - Slide 5/31
 Recorrências - Método da Substituição
● Mas se não funciona para a base, não se pode aceitar a
indução.......
● ...e agora, como resolver?

● Devemos lembrar que a análise assintótica apenas exige

que T(n) = c*n*lg(n) a partir de um n ≥ n0, onde n0 é uma

constante escolhida adequadamente!
●Se, ao invés de 1, selecionarmos a base da nossa

indução como sendo n=2 e n=3 (pois só n=2 ainda

dependeria de n=1....), temos:
T(2) = 2 T(1)+ 2 = 4, e
T(3) = 2 T(3/2) + 3 = 2*1+3 = 5
●Será que o nosso “chute” consegue satisfazer estes casos

base?
IF64C – Estruturas de Dados 2 – Engenharia da Computação – Prof. João Alberto Fabro - Slide 6/31
 Recorrências - Método da Substituição
T(2) ≤ c * 2 * lg(2)

T(3) ≤ c * 3 * lg(3)

●
Como lg(2) = 1, e lg(3) = 1.57, fazendo a constante c≥2, a
base está verificada.

● Desta forma, conseguimos verificar (por indução) que nosso

“chute” realmente satisfaz a recorrência, portanto provamos
que T(n) = O(n*lg(n)) para esta recursão!

Problema desta técnica: como “acertar” o chute?

●

IF64C – Estruturas de Dados 2 – Engenharia da Computação – Prof. João Alberto Fabro - Slide 7/31
 Recorrências - Método da Substituição
T(2) ≤ c * 2 * lg(2)

T(3) ≤ c * 3 * lg(3)

●
Como lg(2) = 1, e lg(3) = 1.57, fazendo a constante c≥2, a
base está verificada.

● Desta forma, conseguimos verificar (por indução) que nosso

“chute” realmente satisfaz a recorrência, portanto provamos
que T(n) = O(n*lg(n)) para esta recursão!

Problema desta técnica: como “acertar” o chute?

●

IF64C – Estruturas de Dados 2 – Engenharia da Computação – Prof. João Alberto Fabro - Slide 8/31
 Recorrências - Método da Substituição

Problema desta técnica: como “acertar” o chute?

●

● Comparação com soluções anteriormente conhecidas:

T(n) = 2 T(n/2+17) + n

● Qual “chute” você daria?

T(n) = O(n lg(n))????
● Mas e a constante “17”? Será que dá alguma diferença?

● Fica como Exercício!!!!!

IF64C – Estruturas de Dados 2 – Engenharia da Computação – Prof. João Alberto Fabro - Slide 9/31
 Recorrências - Método da Substituição
Mais alguns detalhes:

● Considere a seguinte recorrência:

T(n) = T(n/2) + T(n/2) + 1

● Qual “chute” você daria?

T(n) = O(n), provar que T(n) ≤ cn
● Substituindo, temos:

T(n) ≤ c*n/2+c*n/2+1 = cn +1
● Porém isto não implica que T(n) ≤ cn para nenhum c

● Errei por 1?Como resolver, se achamos que isto é O(n)?

IF64C – Estruturas de Dados 2 – Engenharia da Computação – Prof. João Alberto Fabro - Slide 10/31
 Recorrências - Método da Substituição
●
Utilizando outra hipótese, por exemplo T(n) ≤ cn – b
● Substituindo, temos:
T(n) ≤ (c*n/2-b)+(c*n/2-b)+1 = cn -2b +1 ≤cn -b
para todo b≥1.

●Basta escolher c de forma a satisfazer as condições da

base, e conseguimos provar que T(n)=O(n)!!!

●
Mas cuidado.... Lembra de T(n) = 2 T(n/2) + n ?
●
Supondo que a solução seja T(n) = O (n), ou T(n) ≤ cn
T(n) ≤ 2*c*n/2 + n = cn +n,
●Portanto está provado que T(n)=O(n)? NÃO!!!!!

●Porquê?

IF64C – Estruturas de Dados 2 – Engenharia da Computação – Prof. João Alberto Fabro - Slide 11/31
 Recorrências - Método da Substituição

Problema desta técnica: como “acertar” o chute?

●

●Técnicas alternativas: iniciar provando “limites superiores(O)”

e “inferiores(Ω)”, e posteriormente ir “apertando” os limites
(aproximações sucessivas).

● Utilizar o método da árvore de recursão

Exercícios:
4.1-1 – Provar que T(n) = T(n/2) + 1 é O(lg n)
4.1-2 – Provar que T(n) = 2T(n/2) + n é Ω(n lg n). É possível
concluir que T(n) é Ω (n lg n)?
IF64C – Estruturas de Dados 2 – Engenharia da Computação – Prof. João Alberto Fabro - Slide 12/31
 Recorrências - Árvore de Recursão
● Método da Árvore de Recursão
● Boa alternativa para obter “estimativas”(chutes) para o
método da substituição
● Não pode ser utilizado como forma de prova, por não ser

formal....
● Idéia: “Avaliar” como funciona a recursão, somando os

seus custos, para chegar a um limite assintótico.....

Exemplo: T(n) = T(n/4) + T(n/2) + n²

Qual seria seu chute? O(n²)? O(n lg n)?O(n² lg n)?O(n lg n²)

●

IF64C – Estruturas de Dados 2 – Engenharia da Computação – Prof. João Alberto Fabro - Slide 13/31
Recorrências - Árvore de Recursão
T(n) = T(n/4) + T(n/2) + n²

n²
/ \
/ \
T(n/4) T(n/2)

IF64C – Estruturas de Dados 2 – Engenharia da Computação – Prof. João Alberto Fabro - Slide 14/31
Recorrências - Árvore de Recursão
T(n) = T(n/4) + T(n/2) + n²

n²
/ \
/ \
(n/4)² (n/2)²
/ \ / \
/ \ / \
T(n/16) T(n/8) T(n/8) T(n/4)

IF64C – Estruturas de Dados 2 – Engenharia da Computação – Prof. João Alberto Fabro - Slide 15/31
Recorrências - Árvore de Recursão
T(n) = T(n/4) + T(n/2) + n²

n²
/ \
/ \
(n/4)² (n/2)²
/ \ / \
/ \ / \
(n/16)² (n/8)² (n/8)² (n/4)²
:
:
Θ(1)
IF64C – Estruturas de Dados 2 – Engenharia da Computação – Prof. João Alberto Fabro - Slide 16/31
Recorrências - Árvore de Recursão
T(n) = T(n/4) + T(n/2) + n² (Somando:)

n² .................................. =n²
/ \
/ \
(n/4)² (n/2)²
/ \ / \
/ \ / \
(n/16)² (n/8)² (n/8)² (n/4)²
:
:
Θ(1)
IF64C – Estruturas de Dados 2 – Engenharia da Computação – Prof. João Alberto Fabro - Slide 17/31
Recorrências - Árvore de Recursão
T(n) = T(n/4) + T(n/2) + n² (Somando:)

n² .................................. =n²
/ \
/ \
(n/4)² (n/2)² ................... = 5 n²
/ \ / \ 16
/ \ / \
(n/16)² (n/8)² (n/8)² (n/4)²
:
:
Θ(1)
IF64C – Estruturas de Dados 2 – Engenharia da Computação – Prof. João Alberto Fabro - Slide 18/31
Recorrências - Árvore de Recursão
T(n) = T(n/4) + T(n/2) + n² (Somando:)

n² .................................. =n²
/ \
/ \
(n/4)² (n/2)² ................... = 5 n²
/ \ / \ 16
/ \ / \
(n/16)² (n/8)² (n/8)² (n/4)²...............= 25 n²
: 256
: _______
Θ(1) n²+(5/16)n²+(25/256)n²
IF64C – Estruturas de Dados 2 – Engenharia da Computação – Prof. João Alberto Fabro - Slide 19/31
Recorrências - Árvore de Recursão
T(n) = T(n/4) + T(n/2) + n² (Somando:)

n² .................................. =n²
/ \
/ \
(n/4)² (n/2)² ................... = 5 n²
/ \ / \ 16
/ \ / \
(n/16)² (n/8)² (n/8)² (n/4)²...............= 25 n²
: 256
: _______
Θ(1) n²(1+(5/16)+(25/256)+...)
IF64C – Estruturas de Dados 2 – Engenharia da Computação – Prof. João Alberto Fabro - Slide 20/31
Recorrências - Árvore de Recursão
T(n) = T(n/4) + T(n/2) + n² (Somando:)

n² .................................. =n²
/ \
/ \
(n/4)² (n/2)² ................... = 5 n²
/ \ / \ 16
/ \ / \
(n/16)² (n/8)² (n/8)² (n/4)²...............= 25 n²
: 256
: _______
Θ(1) Θ(n²)
IF64C – Estruturas de Dados 2 – Engenharia da Computação – Prof. João Alberto Fabro - Slide 21/31
 Recorrências - Árvore de Recursão
T(n) = T(n/4) + T(n/2) + n² é Θ(n²)????

Somente provando pelo Método da Substituição para ter

certeza realmente......

Exercício: Construa a árvore de recursão para

T(n) = 4T(n/2) + n

E verifique os limites assintóticos(superior e inferior) pelo

método da substituição

IF64C – Estruturas de Dados 2 – Engenharia da Computação – Prof. João Alberto Fabro - Slide 22/31
 Recorrências
● Método Master
●Fornece uma “receita” para resolução de recorrências da
forma:
T(n) = aT(n/b) +f(n)
onde a≥1, e b>1 são constantes e f(n) é uma função
assintoticamente positiva.

●O método Master resolve recorrências de algoritmos do

tipo “dividir-e-conquistar”, onde:
● um problema de tamanho “n” é dividido em “a” sub-

problemas, cada um resolvido em tempo T(n/b).

● A função f(n) descreve o custo de dividir o problema, e

combinar as soluções parciais.

IF64C – Estruturas de Dados 2 – Engenharia da Computação – Prof. João Alberto Fabro - Slide 23/31
 Recorrências - Método Master
O método Master requer a memorização de três
casos base, mas isto permite a resolução de
muitas recorrências com facilidade.

1. f(n) = O(nlogba–ε) para alguma constante ε> 0.

2. f(n) = Θ(nlogba).
log a+ε
3. f(n) = Ω(n b ) para alguma constante ε> 0, e
af(n/b) ≤ cf(n) para alguma constante c < 1 e n
suficientemente grande.

IF64C – Estruturas de Dados 2 – Engenharia da Computação – Prof. João Alberto Fabro - Slide 24/31
 Recorrências - Método Master
Caso 1:

1. f(n) = O(nlogba–ε) para alguma constante ε> 0.

Se isto for verdade, f(n) cresce polinomialmente

mais lentamente que nlogba (por um factor nε).

Solução: T(n) = Θ(nlogba).

IF64C – Estruturas de Dados 2 – Engenharia da Computação – Prof. João Alberto Fabro - Slide 25/31
 Recorrências - Método Master
Caso 2:

2. f(n) = Θ(nlogba).

Se isto for verdade, f(n) e nlogba crescem a taxas

similares.
log a
Solução: T(n) = Θ(n b lg n).

IF64C – Estruturas de Dados 2 – Engenharia da Computação – Prof. João Alberto Fabro - Slide 26/31
 Recorrências - Método Master
Caso 3:

3. f(n) =Ω(nlogba+ε) para alguma constante ε> 0, e

af(n/b) ≤ cf(n) para alguma constante c < 1 e n
suficientemente grande.

Se isto for verdade, f(n) cresce polinomialmente

mais rapidamente que nlogba a uma taxa nε.

Solução: T(n) = Θ(f(n)).

IF64C – Estruturas de Dados 2 – Engenharia da Computação – Prof. João Alberto Fabro - Slide 27/31
 Recorrências - Método Master
Exemplos:

T(n) = 4T(n/2) + n
a =4, b= 2 ⇒nlogba =n2 ; f(n) = n.
2-ε
CASo1: f(n) = O(n ) para ε= 1.
∴T(n) = Θ(n2).

IF64C – Estruturas de Dados 2 – Engenharia da Computação – Prof. João Alberto Fabro - Slide 28/31
 Recorrências - Método Master
Exemplos:

T(n) = 4T(n/2) + n2
a =4, b= 2 ⇒n b =n ; f(n) = n .
log a 2 2

CASo2: f(n) = Θ(n2).

∴T(n) = Θ(n2lg n).

IF64C – Estruturas de Dados 2 – Engenharia da Computação – Prof. João Alberto Fabro - Slide 29/31
 Recorrências - Método Master
Exemplos:

T(n) = 4T(n/2) + n3
a =4, b= 2 ⇒n b =n ; f(n) = n .
log a 2 3

●
CASo3: f(n) = Ω(n2+ε), para ε=1 e 4(n/2)3≤cn3 para
c= 1/2.
∴T(n) = Θ(n3).

IF64C – Estruturas de Dados 2 – Engenharia da Computação – Prof. João Alberto Fabro - Slide 30/31
 Recorrências - Método Master
Exemplos:

T(n) = 2T(n/2) + n lg n
a =2, b= 2 ⇒nlogba =n ; f(n) = n lg n.

● O método Master não se aplica! Por quê?

● O teste: af(n/b) ≤ cf(n) para c < 1 e n grande:
2(n/2 lg(n/2)) =n lg(n/2) ≤ c n lg(n) (OK!)
●
Mas f(n) =Ω(nlogba+ε) para alguma constante ε> 0?
●
f(n)/nlogba =f(n)/n=n lg n/n = lg n.
ε
●
lg n < n para algum ε> 0??? NÃO!!!!!
● (não é polinomialmente menor!!!!!)
IF64C – Estruturas de Dados 2 – Engenharia da Computação – Prof. João Alberto Fabro - Slide 31/31