MO417 — Complexidade de Algoritmos I

Cid Carvalho de Souza Cândida Nunes da Silva

Orlando Lee
Estatı́sticas de Ordem

19 de setembro de 2011

Revisado por Zanoni Dias

Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1 Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1

Estatı́sticas de Ordem (Problema da Seleção) Mı́nimo

Estamos interessados em resolver o Recebe um vetor A[1 . . . n] e devolve o mı́nimo do vetor.

Problema da Seleção: M ÍNIMO(A, n)

Dado um conjunto A de n números reais e um inteiro i, 1 mı́n ← A[1]
determinar o i-ésimo menor elemento de A. 2 para j ← 2 até n faça
Casos particulares importantes: 3 se mı́n > A[j]
4 então mı́n ← A[j]
Mı́nimo : i = 1
5 devolva mı́n
Máximo : i = n
Número de comparações: n − 1 = Θ(n)
Mediana : i = ⌊ n+1
2 ⌋ (mediana inferior)
Aula passada: não é possı́vel fazer com menos comparações.
Mediana : i = ⌈ n+1
2 ⌉ (mediana superior)

Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1 Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1
 Mı́nimo e máximo Mı́nimo e máximo

Recebe um vetor A[1 . . . n] e devolve o mı́nimo e o máximo do Processe os elementos em pares. Para cada par, compare
vetor. o menor com o mı́nimo atual e o maior com o máximo
atual. Isto resulta em 3 comparações para cada 2
M IN M AX(A, n) elementos.
1 mı́n ← máx ← A[1] Se n for ı́mpar, inicialize o mı́nimo e o máximo como
2 para j ← 2 até n faça sendo o primeiro elemento.
3 se A[j] < mı́n
Se n for par, inicialize o mı́nimo e o máximo comparando
4 então mı́n ← A[j]
os dois primeiros elementos.
5 se A[j] > máx
6 então máx ← A[j] Número de comparações:
7 devolva (mı́n, máx)
3⌊n/2⌋ se n for ı́mpar
Número de comparações: 2(n − 1) = 2n − 2 = Θ(n) 3⌊n/2⌋ − 2 se n for par
É possı́vel fazer melhor! Pode-se mostrar que isto é o melhor possı́vel.
(Exercı́cio ⋆ do CLRS)

Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1 Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1

Problema da Seleção – primeira solução Relembrando – Partição

Recebe A[1 . . . n] e i tal que 1 ≤ i ≤ n Problema: rearranjar um dado vetor A[p . . . r ] e devolver um
e devolve valor do i-ésimo menor elemento de A[1 . . . n] ı́ndice q, p ≤ q ≤ r , tais que

S ELECT-O RD(A, n, i) A[p . . . q − 1] ≤ A[q] < A[q + 1 . . . r ]

1 O RDENE(A, n)
2 devolva A[i] Entrada:
p r
O RDENE pode ser MergeSort ou HeapSort. A 99 33 55 77 11 22 88 66 33 44

A complexidade de tempo de S ELECT-O RD é O(n lg n).

Saı́da:
p q r
Será que não dá para fazer melhor que isso?
A 33 11 22 33 44 55 99 66 77 88
Afinal, consigo achar o mı́nimo e/ou máximo em tempo O(n).

Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1 Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1
 Relembrando – Particione Problema da Seleção – segunda solução

Rearranja A[p . . . r ] de modo que p ≤ q ≤ r e

Suponha que queremos achar o i-ésimo menor de A[1 . . . n].
A[p . . . q−1] ≤ A[q] < A[q+1 . . . r ].
Executamos PARTICIONE e este rearranja o vetor e
PARTICIONE(A, p, r ) devolve um ı́ndice k tal que
1 x ← A[r ] ⊲ x é o “pivô”
2 i ← p−1 A[1 . . . k − 1] ≤ A[k ] < A[k + 1 . . . n].
3 para j ← p até r − 1 faça
4 se A[j] ≤ x Eis a idéia do algoritmo:
5 então i ← i + 1 Se i = k , então o pivô A[k ] é o i-ésimo menor!
6 A[i] ↔ A[j] Se i < k , então o i-ésimo menor está em A[1 . . . k − 1];
7 A[i+1] ↔ A[r ] Se i > k , então o i-ésimo menor está em A[k + 1 . . . n].
8 devolva i + 1

Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1 Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1

Problema da Seleção – segunda solução Segunda solução – complexidade

Recebe A[p . . . r ] e i tal que 1 ≤ i ≤ r −p+1 S ELECT-NL(A, p, r , i) Tempo

e devolve o i-ésimo menor elemento de A[p . . . r ]. 1 se p = r ?
2 então devolva A[p] ?
S ELECT-NL(A, p, r , i) 3 q ← PARTICIONE(A, p, r ) ?
1 se p = r 4 k ←q−p+1 ?
2 então devolva A[p] 5 se i = k ?
3 q ← PARTICIONE(A, p, r ) 6 então devolva A[q] ?
4 k ←q−p+1 7 senão se i < k ?
5 se i = k ⊲ pivô é o i-ésimo menor! 8 então devolva S ELECT-NL(A, p, q − 1, i) ?
6 então devolva A[q] 9 senão devolva S ELECT-NL(A, q + 1, r , i − k) ?
7 senão se i < k
8 então devolva S ELECT-NL(A, p, q − 1, i) T (n) = complexidade de tempo no pior caso quando
9 senão devolva S ELECT-NL(A, q + 1, r , i − k) n =r −p+1

Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1 Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1
 Segunda solução – complexidade Segunda solução – complexidade

S ELECT-NL(A, p, r , i) Tempo
1 se p = r Θ(1)
2 então devolva A[p] O(1)
3 q ← PARTICIONE(A, p, r ) Θ(n)
A complexidade de S ELECT-NL no pior caso é Θ(n2 ).
4 k ←q−p+1 Θ(1)
5 se i = k Θ(1) Então é melhor usar S ELECT-O RD?
6 então devolva A[q] O(1) Não, S ELECT-NL é muito eficiente na prática.
7 senão se i < k O(1) Vamos mostrar que no caso médio S ELECT-NL tem
8 então devolva S ELECT-NL(A, p, q − 1, i) T (k − 1) complexidade O(n).
9 senão devolva S ELECT-NL(A, q + 1, r , i − k) T (n − k)

T (n) = max{T (k − 1), T (n − k )} + Θ(n)

T (n) ∈ Θ(n2 ) (Exercı́cio)

Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1 Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1

S ELECT aleatorizado Algoritmo S ELECT-A LEAT

Recebe A[p . . . r ] e i tal que 1 ≤ i ≤ r −p+1

e devolve o i-ésimo menor elemento de A[p . . . r ]
O pior caso do S ELECT-NL ocorre devido a uma escolha infeliz
do pivô. S ELECT-A LEAT(A, p, r , i)
Um modo de evitar isso é usar aleatoriedade (como no 1 se p = r
Q UICK S ORT-A LEAT ÓRIO). 2 então devolva A[p]
3 q ← PARTICIONE -A LEAT ÓRIO(A, p, r )
PARTICIONE -A LEAT ÓRIO(A, p, r ) 4 k ←q−p+1
1 j ← R ANDOM(p, r ) 5 se i = k ⊲ pivô é o i-ésimo menor
2 A[j] ↔ A[r ] 6 então devolva A[q]
3 devolva PARTICIONE(A, p, r ) 7 senão se i < k
8 então devolva S ELECT-A LEAT(A, p, q − 1, i)
9 senão devolva S ELECT-A LEAT(A, q + 1, r , i − k)

Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1 Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1
 Análise do caso médio Análise do caso médio

n
Recorrência para o caso médio de S ELECT-A LEAT. 1X
T (n) ≤ T (max{k − 1, n − k}) + an
T (n) = complexidade de tempo médio de S ELECT-A LEAT. n
k =1
n−1
2 X
≤ T (k) + an
T (0) = Θ(1) n
k =⌊n/2⌋
T (1) = Θ(1)
n pois
1X 
k − 1 se k > ⌈n/2⌉,
T (n) ≤ T (max{k − 1, n − k}) + Θ(n). max{k − 1, n − k} =
n n − k se k ≤ ⌈n/2⌉.
k =1
Se n é par, cada termo de T (⌈n/2⌉) a T (n − 1) aparece
exatamente duas vezes na somatória.
T (n) é Θ(???). Se n é ı́mpar, esses termos aparecem duas vezes e T (⌊n/2⌋)
aparece uma vez.

Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1 Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1

Demonstração: T (n) ≤ cn Demonstração: T (n) ≤ cn

 
n−1
2c (n − 1)n (⌊n/2⌋ − 1)⌊n/2⌋
2 T (n) = − + an
n 2 2
X
T (n) ≤ T (k) + an
n  
k =⌊n/2⌋ 2c (n − 1)n (n/2 − 2)(n/2 − 1)
≤ − + an
hi n−1 n 2 2
2 X
≤ ck + an c 3n2 n
 
n = + − 2 + an
k =⌊n/2⌋
  n 4 2
n−1 ⌊n/2⌋−1
2c X X 3cn c
= k− k  + an ≤ + + an
n 4 2
k =1 k =1  cn c 
  = cn − − − an ≤ cn.
2c (n − 1)n (⌊n/2⌋ − 1)⌊n/2⌋ 4 2
= − + an
n 2 2
Isto funciona se c > 4a e n ≥ 2c/(c − 4a).
Logo, T (n) = O(n).

Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1 Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1
 Conclusão Problema da Seleção – terceira solução

A complexidade de tempo de S ELECT-A LEAT no caso médio é Problema da Seleção:

O(n). Dado um conjunto A de n números reais e um inteiro i,
determinar o i-ésimo menor elemento de A.
Na verdade,
Veremos um algoritmo linear para o Problema da Seleção.
A complexidade de tempo de S ELECT-A LEAT no caso médio é
Θ(n). BFPRT = Blum, Floyd, Pratt, Rivest e Tarjan

Para simplificar a exposição, vamos supor que os elementos

Veremos depois: em A são distintos.
Algoritmo que resolve o Problema da Seleção em tempo linear
(no pior caso).

Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1 Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1

Problema da Seleção – terceira solução Problema da Seleção – terceira solução

Divida os n elementos em n5 subconjuntos de 5
 
1
3 Determine, recursivamente, a mediana x das medianas
elementos e um subconjunto de n mod 5 elementos.
dos subconjuntos de no máximo 5 elementos.
1 • • ... • • • ... • •
2 • • ... • • • ... • • • • ... • • • ... •
• • ... • • • ... • • n • • ... • • • ... • •
• • ... • • • ... • ◦ ◦ ... ◦ ◦ ◦ ... ◦ ◦
• • ... • • • ... • • • ... • • • ... • •
n • • ... • • • ... •
2 Encontre a mediana de cada um dos 5 subconjuntos.
A figura acima é a mesma que a anterior, com as colunas
1 • • ... • • • ... •
2 • • ... • • • ... • • ordenadas pela mediana de cada grupo. A ordem dos
◦ ◦ ... ◦ ◦ ◦ ... ◦ ◦ elementos em cada coluna permanece inalterada.
• • ... • • • ... • • n Por simplicidade de exposição, supomos que a última
• • ... • • • ... • coluna permanece no mesmo lugar.
Note que o algoritmo não ordena as medianas!
Na figura acima, cada subconjunto está em ordem
crescente, de cima para baixo.
Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1 Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1
 Problema da Seleção - terceira solução Problema da Seleção - terceira solução

5 Finalmente, para encontrar o i-ésimo menor elemento do

conjunto, compare i com a posição k de x após o
particionamento:
4 Usando x como pivô, particione o conjunto original A
Se i = k , x é o elemento procurado;
criando dois subconjuntos A< e A> , onde
Se i < k , então determine recursivamente o i-ésimo menor
A< contém os elementos < x e elemento do subconjunto A< ;
A> contém os elementos > x. Senão, determine recursivamente o (i − k)-ésimo menor
Se a posição final de x após o particionamento é k, então elemento do subconjunto A> .
|A< | = k − 1 e |A> | = n − k.
Note que esta parte é idêntica ao feito em S ELECT-NL e em
S ELECT-A LEAT. O que diferencia este algoritmo dos outros é a
escolha do pivô. Escolhendo-se a mediana das medianas,
vamos poder garantir que nenhum dos lados é muito “grande”.

Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1 Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1

Terceira solução – complexidade Terceira Solução - Complexidade

T (n) : complexidade de tempo no pior caso O diagrama abaixo classifica os elementos da última figura.

  ...   • ... •
1 Divisão em subconjuntos de 5 elementos. Θ(n)   ...   • ... • •  = < x
2 Encontrar a mediana de cada subconjunto. Θ(n)   ...  x △ ... △ △ △ = > x
3 Encontrar x, a mediana das medianas. T (⌈n/5⌉) • • ... • △ △ ... △ △ • = ?
• • ... • △ △ ... △
4 Particionamento com pivô x. O(n)
5 Encontrar o i-ésimo menor de A< T (k − 1) Veja que o número de elementos > x, isto é △s, é no mı́nimo
OU encontrar o i − k -ésimo menor de A> . T (n − k) 3n
10 − 6.
Temos então a recorrência Isto porque no mı́nimo ⌈ 12 ⌈ n5 ⌉⌉ grupos contribuem com 3
T (n) = T (⌈n/5⌉) + T (max{k − 1, n − k}) + Θ(n) elementos > x, exceto possivelmente
o último e aquele que
contém x. Portanto, 3 ⌈ 21 ⌈ n5 ⌉⌉ − 2 ≥ 3n
10 − 6.

Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1 Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1
 Terceira Solução - Complexidade Solução da recorrência: T (n) ≤ cn

Da mesma forma, o número de elementos < x, isto é s, é no

mı́nimo 3n
10 − 6. T (n) ≤ T (⌈n/5⌉) + T (⌊7n/10⌋ + 6) + an
Assim, no passo 5 do algoritmo, hi
  ≤ c⌈n/5⌉ + c(⌊7n/10⌋ + 6) + an
3n 7n
max{k − 1, n − k} ≤ n − −6 ≤ + 6. ≤ c(n/5 + 1) + c(7n/10 + 6) + an
10 10
= 9cn/10 + 7c + an
A recorrência T (n) está agora completa: = cn + (−cn/10 + 7c + an)
 ≤ cn,
Θ(1), n ≤ 140
T (n) ≤
T (⌈n/5⌉) + T (⌊7n/10⌋ + 6) + Θ(n), n > 140,
Quero que (−cn/10 + 7c + an) ≤ 0.
140 é um número suficientemente grande que faz as contas Isto equivale a c ≥ 10a(n/(n − 70)) quando n > 70. Como
funcionarem. . . n > 140, temos n/(n − 70) ≤ 2 e assim basta escolher
A solução é T (n) ∈ Θ(n) c ≥ 20a.

Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1 Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1

Algoritmo S ELECT PARTICIONE -BFPRT

Recebe A[p . . . r ] e i tal que 1 ≤ i ≤ r −p+1

e devolve um ı́ndice q tal que A[q] é o i-ésimo menor elemento
de A[p . . . r ].
S ELECT(A, p, r , i) Rearranja A[p . . . r ] e devolve um ı́ndice q, p ≤ q ≤ r , tal que
1 se p = r A[p . . . q−1] ≤ A[q] < A[q+1 . . . r ] e
2 então devolva p ⊲ p e não A[p]  
7n
3 q ← PARTICIONE -BFPRT(A, p, r ) max{k − 1, n − k} ≤ + 6,
10
4 k ←q−p+1
5 se i = k onde n = r − p + 1 e k = q − p + 1.
6 então devolva q ⊲ q e não A[q]
7 senão se i < k
8 então devolva S ELECT(A, p, q − 1, i)
9 senão devolva S ELECT(A, q + 1, r , i − k)

Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1 Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1
 PARTICIONE -BFPRT PARTICIONE -BFPRT

PARTICIONE -BFPRT(A, p, r ) ⊲ n := r − p + 1
1 para j ← p, p+5, p+5 · 2, . . . até p+5(⌈n/5⌉−1) faça
2 O RDENE(A, j, j+4)
Divida o vetor em ⌊n/5⌋ grupos de tamanho 5 e um grupo
≤ 5, 3 O RDENE(A, p+5⌊n/5⌋, n)
ordene cada grupo e determine a mediana de cada um 4 para j ← 1 até ⌈n/5⌉−1 faça
deles, 5 A[j] ↔ A[p+5j−3]
determine a mediana das medianas chamando S ELECT (!!) 6 A[⌈n/5⌉] ↔ A[⌊(p+5⌊n/5⌋+n)/2⌋]
e particione o vetor em torno desse valor.
7 k ← S ELECT(A, p, p+⌈n/5⌉−1, ⌊(⌈n/5⌉+1)/2⌋)

8 A[k ] ↔ A[r ]
9 devolva PARTICIONE(A, p, r )

Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1 Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1

Exercı́cios Exercı́cios

Exercı́cio 3 Dado um conjunto de n números, queremos

imprimir em ordem crescente os i maiores elementos deste
Exercı́cio 1 Mostre como modificar Q UICK S ORT de modo que usando um algoritmo baseado em comparações.
tenha complexidade de tempo Θ(n lg n) no pior caso. Compare a complexidade dos seguinte métodos em função de
n e i.
Exercı́cio 2 Suponha que você tenha uma subrotina do tipo
Ordene o vetor e liste os i maiores elementos.
“caixa-preta” que determina a mediana em tempo linear (no
pior caso). Descreva um algoritmo linear simples que resolve o Construa uma fila de prioridade (max-heap) e chame a
problema da seleção para todo i. rotina E XTRACT-M AX i vezes.
Use um algoritmo de seleção para encontrar o i-ésimo
maior elemento, particione o vetor em torno dele e ordene
os i maiores elementos.

Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1 Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1