PAA-DCC-UFAM

Somatórios e Recorrências

Universidade Federal do Amazonas

Departamento de Eletrônica e Computação
PAA-DCC-UFAM

Exemplo: MaxMin (1)

Problema:
Dado um vetor de inteiros A, encontrar o maior e o
menor elementos de A
O número de comparações entre elementos de A é
dado por T(n) = 2 (n-1) para qualquer caso

MaxMin(A[1…n])
Max ← Α[1]; Min ← Α[1];
for i = 2 … n (n)
if A[i] > Max then Max ← Α[i ]; (n-1)
if A[i] < Min then Min ← Α[i ]; (n-1)
end_for
PAA-DCC-UFAM

Exemplo: MaxMin (2)

Versão 2
Melhor caso: A está em ordem crescente T(n) = n-1
Pior caso: A está em ordem decrescente T(n) = 2(n-1)
Caso médio: T(n) = n-1 + (n-1)/2 = 3n/2 – 3/2

MaxMin2(A[1…n])
Max ← Α[1]; Min ← Α[1];
for i = 2 … n
if A[i] > Max then Max ← Α[i ];
else if A[i] < Min then Min ← Α[i ];
end_for
PAA-DCC-UFAM

Exemplo: MaxMin (3)

MaxMin3(A[1…n])
if (n mod 2)>0 then u ← n; A[n+1]=A[n]
else u ← n-1;
if A[1]>A[2] then Max ← Α[1]; Min ← Α[2]
else Min ← Α[1]; Max ← Α[2]
i ← 3;
while i ≤ u do
if A[i]>A[i+1] then
if A[i] > Max then Max ← Α[i];
if A[i+1] < Min then Min ← Α[i+1];
else
if A[i] < Min then Min ← Α[i];
if A[i+1] > Max then Max ← Α[i+1];
i ← i+2;
end-while
PAA-DCC-UFAM

Exemplo: MaxMin (4)

Contém o máximo

Contém o mínimo

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

= 3n/2 –2 = O (n)
 Resolvendo somatórios
PAA-DCC-UFAM

Algumas técnicas úteis

Procurar resposta e conferir
Vale principalmente para o dia-a-dia
Indução
Perturbação
Usar integrais
PAA-DCC-UFAM

Prova por indução (1)

Deseja-se mostrar que uma propriedade P é
verdadeira para todo inteiro n ≥ n0
Base:
provar que P é verdadeiro para n0
Passo indutivo:
provar que
se P é verdadeiro para todo k
tal que n0 ≤ k ≤ n – 1
então P é verdadeiro para n
PAA-DCC-UFAM

Prova por indução (2)

Exemplo
n
n(n + 1)
S ( n) = ∑ i = for n ≥ 1
i =0 2

Base: Provar que S(n0)=1 é verdadeiro

1
1(1 + 1)
S (1) = ∑ i = n0 = 1
i =0 2
PAA-DCC-UFAM

Prova por indução (3)

Passo indutivo Caso base provou para o limite 1

k
k ( k + 1)
S (k ) = ∑
i=0
i=
2
, 1 ≤ k ≤ n −1
for
Provar para o limite
n n −1

∑ i = ∑ i + n = S ( n − 1) + n =
n-1
S (n) =
i=0 i=0

( n − 1 + 1) (n 2 − n + 2n)
= ( n − 1) +n= =
2 2
n ( n + 1)
=
2
PAA-DCC-UFAM

Exercício: Prova por indução

Prove que
n
S n = ∑ a = na para n ≥ 1
i =1

Base: Provar que S(n0)=a é verdadeiro

n
S n = ∑ a = 1.a n0 = 1
i =1
PAA-DCC-UFAM

Exercício: Prova por indução

Passo indutivo
k
S k = ∑ a = ka para 1 ≤ k ≤ n - 1
i =1
n n −1
Sn = ∑ a = ∑ a + a = S (n − 1) + a
i =1 i =1

= (n − 1).a + a = na − a + a
= na
PAA-DCC-UFAM

Somatórios (1)
O tempo de execução da ordenação por inserção
é determinado pelos loops aninhados:
for j←2 to length(A)
key←A[j]
i←j-1
while i>0 and A[i]>key
A[i+1]←A[i]
i←i-1
A[i+1]←key

Loops aninhados correspondem a somatórios

aninhados
PAA-DCC-UFAM

Somatórios (2)
Progressão aritmética
n
n2 + n
∑
i =0
i = 1 + 2 + 3 + ... + n =
2

Progresão geométrica
Seja um inteiron0 e um real 0 < a ≠ 1
n
1 − a n +1
∑
i =0
i 2
a = 1 + a + a + ... + a = n

1− a

Progressões geométricas apresentam crescimento

exponencial
PAA-DCC-UFAM

Algumas propriedades

∑cak =c∑ak
k∈K k∈K
Distributiva

∑(ak +bk ) = ∑ak +∑bk

k∈K k∈K k∈K
Associativa

∑a = ∑a
k∈K
k
p(k)∈K
P(k) Comutativa
(P é uma permutação)
PAA-DCC-UFAM

Exercício: Prova por indução (1)

n
Demostrar que a série geométrica ∑ 3k = Ο(3n )
k =0
n
Vamos provar que ∑ 3
k =0
k
≤ c3 n

n
Base: Condição inicial n0=0, temos: ∑ 3k ≤ c3n = 1 ≤ c
k =0

Passo indutivo: Supondo que o limite se

mantenha válido para n, vamos provar que ele é
válido para n+1
PAA-DCC-UFAM

Exercício: Prova por indução (2)

n
Passo indutivo: Provar para n+1 ∑ 3
k =0
k
≤ c3 n

n +1 n

∑ ∑
3 =
k =0
3 k
k
+ 3 n +1

k =0

≤ c3n + 3n +1
1 1
=  + c3n +1
3 c
≤ c3n +1
1 1 3
desde que  +  ≤ 1 ou, de modo equivalente, c ≥
3 c 2
PAA-DCC-UFAM

Exemplo
for j←2 to |A|
key←A[j]
Ordenação por i←j-1
while i>0 and A[i]>key
Inserção A[i+1]←A[i]
i←i-1
A[i+1]←key

|A| = 2 → 1
|A| = 3 → 1+2
|A| = 4 → 1+2+3
...
|A| = n → 1 + 2 + 3 + … + n-1
PAA-DCC-UFAM

Perturbação (1)
Escrever Sn+1 tirando o primeiro termo e igualar a
Sn+1 tirando o último termo
Encontrar Sn dos dois lados da equação
Isolar Sn para encontrar a fórmula fechada para o
somatório
PAA-DCC-UFAM

Perturbação (2)
n
S n = ∑ ak
k =0

S n +1 = S n + an +1 Tirando o último termo

n +1 n
S n +1 = a0 + ∑ ak = a0 + ∑ ak +1 Tirando o primeiro
termo
k =1 k =0

O truque agora consiste em quebrar o termo do somatório para chegar a Sn

PAA-DCC-UFAM

Perturbação (3)
n
Sn = ∑ c k
k =0

S n +1 = S n + c n +1
n +1 n n
S n +1 = c + ∑ c = 1 + ∑ c
0 k k +1
= 1 + c ∑ c = 1 + cS n
k

k =1 k =0 k =0

1 + cS n = S n + c n +1
n +1
c−1
Sn =
c −1
PAA-DCC-UFAM

Exercício: Perturbação
n
Encontre a fórmula fechada para ∑ a
k =1
k

n
Sn = ∑ a k
k =1

S n +1 = S n + a n +1
n +1 n n
S n +1 = a1 + ∑ a k = a + ∑ a k +1 = a + a ∑ a k = a + aS n
k =2 k =1 k =1

S n + a n +1 = a + aS n
a n +1 − a
Sn =
a −1
PAA-DCC-UFAM

Integrais
Integrais podem ser usadas para
encontrarmos o valor aproximado de um
somatório, indicando seu comportamento
assintótico
Exemplo:

∑i =0 ∫
n 2
i = O ( i ) = O ( n )
0
PAA-DCC-UFAM

Exercício: Integrais
Encontre o valor aproximado dos seguintes
n n n
somatório: ∑ a, ∑ i , ∑ 1 3

i =1 i =1 i =1 i

n n 
∑ a = Ο ∫ a  = Ο(n )
i =1 1 
n  n

∑ i 3
= Ο 
∫ i 3
 = Ο ( )
n 4

i =1 1 
n
1  n 1
∑
i =1 i
= Ο ∫  = Ο(ln n )
1 i
PAA-DCC-UFAM

Divisão e Conquista
Método usado para projeto de algoritmos:
Divisão: Se o tamanho da entrada é muito grande
para aplicação de uma solução simples, dividir o
problema em dois ou mais subproblemas disjuntos
Conquista: Usar o método recursivamente para
resolver os subproblemas
Combinação: Obter as soluções dos subproblemas e
combiná-las para compor uma solução para o
problema original
PAA-DCC-UFAM

MergeSort
Divisão: Se S tem n≥2 elementos, dividir seus
elementos em duas subsequências S1 e S2 com
respectivamente n/2 e n/2 elementos
Conquista: Ordernar as subsequências S1 e S2
usando MergeSort
Combinação: Intercale os elementos de S1 e S2
de forma a obter uma seqüência ordenada
PAA-DCC-UFAM

Merge Sort: Algoritmo

Analogia com o jogo de cartas
Temos duas pilhas ordenadas com as cartas de menor
valor em cima
Desejamos juntar as duas pilhas (fazendo a
intercalação) em uma única pilha de saída ordenada
1) Escolher a menor das duas cartas nas pilhas

2) Removê-la de sua pilha

3) Colocá-la sobre a pilha de saída

4) Repetir os passos 1,2,3 até uma das duas pilhas de entrada

esvaziarem
PAA-DCC-UFAM

Merge Sort: Algoritmo

Merge-Sort(A, p, r)
if p < r then A é o arranjo
q ← (p+r)/2 p, q e r são índices de
Merge-Sort(A, p, q) numeração dos elementos
Merge-Sort(A, q+1, r)
Merge(A, p, q, r) do arranjo p ≤ q < r

Se p≥ r, o subarranjo tem no máximo um elemento e,

portanto, já está ordenado
Merge(A, p, q, r)
Retire o menor entre o menor dos elementos de
A[p…q] e A[q+1…r] e acrescente ao resultado. Repita
até que as duas sub-sequências estejam vazias
PAA-DCC-UFAM

MergeSort (Exemplo) - 1
PAA-DCC-UFAM

MergeSort (Exemplo) - 2
PAA-DCC-UFAM

MergeSort (Exemplo) - 3
PAA-DCC-UFAM

MergeSort (Exemplo) - 4
PAA-DCC-UFAM

MergeSort (Exemplo) - 5
PAA-DCC-UFAM

MergeSort (Exemplo) - 6
PAA-DCC-UFAM

MergeSort (Exemplo) - 7
PAA-DCC-UFAM

MergeSort (Exemplo) - 8
PAA-DCC-UFAM

MergeSort (Exemplo) - 9
PAA-DCC-UFAM

MergeSort (Exemplo) - 10
PAA-DCC-UFAM

MergeSort (Exemplo) - 11
PAA-DCC-UFAM

MergeSort (Exemplo) - 12
PAA-DCC-UFAM

MergeSort (Exemplo) - 13
PAA-DCC-UFAM

MergeSort (Exemplo) - 14
PAA-DCC-UFAM

MergeSort (Exemplo) - 15
PAA-DCC-UFAM

MergeSort (Exemplo) - 16
PAA-DCC-UFAM

MergeSort (Exemplo) - 17
PAA-DCC-UFAM

MergeSort (Exemplo) - 18
PAA-DCC-UFAM

MergeSort (Exemplo) - 19
PAA-DCC-UFAM

MergeSort (Exemplo) - 20
PAA-DCC-UFAM

MergeSort (Exemplo) - 21
PAA-DCC-UFAM

MergeSort (Exemplo) - 22
PAA-DCC-UFAM

Recorrências
As chamadas recursivas nos algoritmos podem
ser descritas usando-se equações(ou inequações)
de recorrência

Recorrência é uma equação ou desigualdade que

descreve uma função em termos dos seus
valores para entradas menores
PAA-DCC-UFAM

Recorrências (2)
Exemplo: Busca Binária
BuscaBin(A[1…n],q)
if n=1
then if A[n]=q then return n
else return 0

k←(n+1)/2
if q < A[k] then BuscaBin(A[1…k-1],q)
else BuscaBin(A[k…n],q)
PAA-DCC-UFAM

Exemplo: MergeSort
Suposição: O tamanho do problema original é
uma potência de dois (simplificação)
Merge-Sort(A, p, r)
if p < r then
Duas q←(p+r)/2
subsequência Merge-Sort(A, p, q)
s de tamanho Merge-Sort(A, q+1, r)
n/2 Merge(A, p, q, r)
PAA-DCC-UFAM

Procedimento do Merge
Merge(A, p, q, r)
n1 = q-p+1
Θ(1) n2 = r-q
criar arranjos L[0..n1] e R[0..n2]
for i=0 to n1-1
do L[i]=A[p+i] Θ(n1)
for j=0 to n2-1
do R[j]=A[q+j+1]
Θ(n2)
L[n1]=∞
R[n2]=∞
Θ(1) i=0
j=0
for k=p to r
do if L[i] ≤ R[j]
then A[k]=L[i] Θ(n)
i=i+1
else A[K]=R[j]
j=j+1
PAA-DCC-UFAM

Complexidade do MergeSort

Caso base: ocorre quando

n=1. Como lg 1=0, temos
que lg n +1 fornece o
número correto

Hipótese indutiva: uma

árvore de 2i nós, temos lg
2i+1=i+1. Para 2i+1 nós
temos lg 2i+1+1 = (i+1)+1

cn(lg n + 1) = Θ(n lg n )
PAA-DCC-UFAM

Exercícios
Utilize as técnicas de indução, perturbação e
integrais para resolver os seguintes
somatórios: