AULAS4 Up

Anlise de Algoritmos
2008
Paulo Feolo
IME, Universidade de So Paulo
1
Aula 1: Introduo
2
CLRS: Cormen, Leiserson, Rivest, Stein
Having a solid base of algorithmic knowledge and technique
is one characteristic that separates
the truly skilled programmers from the novices.
With modern computing technology,
you can accomplish some tasks
without knowing much about algorithms,
but with a good background in algorithms, you can do much,
much more.
Uma base slida de conhecimento e tcnica de algoritmos
uma das caractersticas que separa
o programador experiente do aprendiz.
Com a moderna tecnologia de computao,
voc pode realizar algumas tarefas
sem saber muito sobre algoritmos,
mas com um boa base em algoritmos voc pode fazer muito,
muito mais.
3
O que AA? Um exemplo
Problema: Rearranjar um vetor em ordem crescente
A[1. . n] crescente se A[1] A[n]
22 33 33 33 44 55 11 99 22 55 77
11 22 22 33 33 33 44 55 55 77 99
4
Algoritmo: Rearranja A[1. . n] em ordem crescente
ORDENA-POR-INSERO (A, n)
1 para j 2 at n faa
2 chave A[j]
3 i j 1
4 enquanto i 1 e A[i] > chave faa
5 A[i +1] A[i]
6 i i 1
7 A[i +1] chave
1 j n
22 33 33 33 44 55 11 99 22 55 77
Note a documentao
5
Anlise da correo: O algoritmo faz o que prometeu?
Invariante: no incio de cada iterao, A[1. . j1] crescente
Se vale na ltima iterao, o algoritmo est correto!
6
ORDENA-POR-INSERO (A, n)
1 para j 2 at (*) n faa
2 chave A[j]
3 i j 1
5 A[i +1] A[i]
6 i i 1
7 A[i +1] chave
1 j n
22 33 33 33 44 55 11 99 22 55 77
vale na primeira iterao
se vale em uma iterao, vale na seguinte
7
Anlise do desempenho: Quanto tempo consome?
Regra de trs
Regra de trs no funciona!
Suponha 1 unidade de tempo por linha
linha total de unidades de tempo
1 = n
2 = n 1
3 = n 1
4 2 +3 + +n = (n 1)(n +2)/2
5 1 +2 + +(n1) = n(n 1)/2
6 1 +2 + +(n1) = n(n 1)/2
7 = n 1
total
3
2
n
2
+
7
2
n 4 unidades de tempo
8
Algoritmo consome
3
2
n
2
+
7
2
n 4 unidades de tempo
3
2
pra valer?
No, pois depende do computador
n
2
pra valer?
Sim, pois s depende do algoritmo
Queremos um resultado que s dependa do algoritmo
9
Outra ttica:
nmero de comparaes A[i] > chave
2 +3 + +n =
1
2
(n 1)(n +2)
1
2
n
2
+
1
2
n 1
1
2
pra valer?
No, pois depende do computador
n
2
pra valer?
Sim, pois s depende do algoritmo
Queremos resultado que s dependa do algoritmo
10
n
2
informao valiosa
mostra evoluo do tempo com n: n n
2
2n 4n
2
10n 100n
2
11
AA in a nutshell
Problema
Instncias do problema
Tamanho de uma instncia
Algoritmo
Anlise da correo do algoritmo
Anlise do desempenho (velocidades) do algoritmo
Desempenho em funo do tamanho das instncias
Pior caso
Evoluo do consumo de tempo em funo de n
Independente do computador e da implementao
12
Aula 2
Notao O
13
Notao O: comparao assinttica de funes
Comparao assinttica grosseira de funes f(n) e g(n)
Qual das duas cresce mais rpido?
Algo com sabor de f(n) g(n)
Despreze valores pequenos de n: n
Despreze constantes multiplicativas: 100n
2
n
2
Despreze termos de ordem inferior: n
2
+10n +10 2n
2
14
f(n) e g(n) assintoticamente no-negativas
Denio: Dizemos que f = O(g) se
existem constantes c > 0 e N > 0 tais que
f(n) c g(n) para todo n N
Em outras palavras: para todo n sucientemente grande,
f(n) dominado por um mltiplo de g(n)
Comentrios:
constante = no dependende de n
f O(g) seria mais correto
15
Exemplo 1
n
2
+10n = O(n
2
)
Prova:
se n 10 ento n
2
+10n n
2
+n n = n
2
+n
2
= 2 n
2
resumo: n
2
+10n 2n
2
para todo n 10
Como adivinhei que 2 e 10 so bons valores para c e N respectivamente?
Resposta: z o seguinte rascunho:
quero n
2
+10n c n
2
dividindo por n
2
, quero 1 +10/n c
se n 10 ento 1 +10/n 2
parece que basta tomar c 2 e N 10
16
Exemplo 2
9n +9 = O(n
2
)
Prova:
se n 9 ento 9n +9 n n +n
2
= 2 n
2
resumo: 9n +9 2n
2
para todo n 9
Outra prova:
se n 1 ento 9n +9 9n n +9 n
2
= 18n
2
17
Exemplo 3
n
2
?
= O(9n +9)
No verdade! Prova, por contradio:
suponha que existem c e N tais que
n
2
c (9n +9) para todo n N
ento n
2
c (9n +9n) = 18c n para todo n N
ento n 18c para todo n N
absurdo
18
Exemplo 4
3n = O(2
n
)
Prova:
vou mostrar que 3n 2
n
para n 4
prova por induo matemtica:
se n = 4 ento 3n = 3 4 = 12 16 = 2
4
= 2
n
se n > 4 ento
3n = 3(n 1 +1)
= 3(n 1) +3
3(n 1) +3(n 1)
2
n1
+2
n1
(hiptese de induo)
= 2
n
Tambm poderia mostrar que 3n 2 2
n
para n 1
19
Exemplo 5
log
2
n = O(n)
Prova:
n 2
n
quando n 1 (como no exemplo anterior)
log
2
crescente
logo, log
2
n n quando n 1
a b se e somente se 2
a
2
b
logo, m n implica log
2
m log
2
n
20
Bases de logaritmos
log
2
n =
log
3
n
log
3
2
=
1
log
3
2
log
3
n
todos os log, qualquer que seja a base,
esto na mesma order O
21
Reprise: algoritmo da ordenao por insero
Desempenho de ORDENA-POR-INSERO:
algoritmo consome O(n
2
) unidades de tempo
no verdade que consome O(n) unidades de tempo
existem instncias que levam o algoritmo a consumir tempo
proporcional a n
2
22
Aula 3
Problema da intercalao (merge)
Mergesort
23
Novo problema/algoritmo: intercalao
Problema: Rearranjar um vetor em ordem crescente sabendo que
o lado e o lado direito so crescentes
Sei fazer em O(n
2
) unidades de tempo
D pra melhorar?
p q r
22 44 55 88 88 33 66 77 99 99 99
p q r
22 33 44 55 66 77 88 88 99 99 99
Possveis valores de p, q e r?
24
Algoritmo: Recebe A[p . . r] tal que A[p . . q] e A[q+1. . r] so
crescentes. Rearranja o vetor todo em ordem crescente.
INTERCALA (A, p, q, r)
1 n
1
q p +1
2 n
2
r q
3 crie vetores L[1. . n
1
+1] e R[1. . n
2
+1]
4 para i 1 at n
1
faa L[i] A[p +i 1]
5 para j 1 at n
2
faa R[j] A[q +j]
6 L[n
1
+1] R[n
2
+1]
.
.
.
.
.
.
25
.
.
.
.
.
.
7 i j 1
8 para k p at r faa
9 se L[i] R[j]
0 ento A[k] L[i]
1 i i +1
2 seno A[k] R[j]
3 j j +1
Anlise do desempenho:
tamanho de instncia: n := r p +1
algoritmo consome O(n) unidades de tempo
isso muito rpido!
26
Novo problema/algoritmo: Mergesort
Algoritmo: Rearranja A[p . . r] em ordem crescente
supondo p r
MERGE-SORT (A, p, r)
1 se p < r
2 ento q (p +r)/2
3 MERGE-SORT(A, p, q)
4 MERGE-SORT(A, q +1, r)
5 INTERCALA (A, p, q, r)
Mtodo de diviso e conquista
Segredo da velocidade do MERGE-SORT: INTERCALA rpido
27
Desempenho: Quanto tempo MERGE-SORT consome?
Tamanho de instncia: n := r p +1
T(n) := tempo para pior instncia de tamanho n
Quero cota superior: T(n) = O(nlgn)
Se n > 1 ento T(n) T
_
_
n
2
_
_
+T
_
_
n
2
_
_
+f(n)
sendo f(n) consumo de tempo de INTERCALA: f(n) = O(n)
Vamos provar que T(n) = O(nlgn)
Notao: lgn := log
2
n e lnn := log
e
n
28
Aula 4
Anlise do Mergesort
Soluo de recorrncias
29
Novo problema/algoritmo: Mergesort
Algoritmo: Rearranja A[p . . r] em ordem crescente, supondo p r
1 se p < r
2 ento q (p +r)/2
Desempenho: Quanto tempo MERGE-SORT consome?
Tamanho de instncia: n := r p +1
T(n) := tempo de pior instncia de tamanho n
Vou mostrar que T(n) = O(nlgn)
30
1 se p < r
2 ento q (p +r)/2
T(n)
_
a se n = 1
T(n/2) +T(n/2) +f(n) se n = 2, 3, 4, 5, . . .
a o consumo de tempo da linha 1
f(n) o consumo de INTERCALA mais o das linhas 1 e 2
Queremos uma frmula fechada para T(n)
31
Exemplo: soluo de recorrncia
Recorrncia semelhante do Mergesort:
T(n) =
_
3 se n = 1
T(n/2) +T(n/2) +10n se n = 2, 3, 4, , . . .
Recorrncia dene funo T sobre inteiros positivos:
n T(n)
1 3 3
2 3 +3 +10 2 26
3 3 +26 +10 3 59
4 26 +26 +10 4 92
5 26 +59 +10 5 135
Quero frmula fechada T(n) =
32
No sei dar uma frmula fechada. . .
Vou comear tentando algo mais simples: somente potncias de 2
S(n) =
_
3 se n = 1
2S(
n
2
) +10n se n = 2
1
, 2
2
, 2
3
, . . .
Frmula fechada: S(n) = 10nlgn +3n
Prova?
Lembrete: lgn := log
2
n
33
Teorema: S(n) = 10nlgn +3n para n = 2
0
, 2
1
, 2
2
, 2
3
, . . .
Prova, por induo matemtica:
Base: se n = 1 ento S(n) = 3 = 10nlgn +3n
Passo: se n > 1 ento
S(n) = 2S(
n
2
) +10n
= 2
_
10
n
2
lg
n
2
+3
n
2
_
+10n (hiptese de induo)
= 10n(lgn 1) +3n +10n
= 10nlgn 10n +3n +10n
= 10nlgn +3n
34
Resposta mais grosseira: S(n) = O(nlgn)
Prova: . . .
35
Como adivinhei a frmula 10nlgn +3n?
Desenrolei a recorrncia:
S(n) = 2S(n/2) +10n
= 4S(n/4) +20n
= 8S(n/8) +30n
.
.
.
.
.
.
= nS(1) +10 lgnn
= 3n +10n lgn
36
De volta ao desempenho do Mergesort
T(n) T
_
_
n
2
_
_
+T
_
_
n
2
_
_
+ O(n)
Diferenas em relao ao exemplo anterior:
no lugar de =
. e .
1, 2, 3, 4, 5, . . . no lugar de 2
0
, 2
1
, 2
2
, 2
3
, . . .
O(n) no lugar de f(n)
Apesar dessas diferenas, CLRS (sec.4.3 p.7375) garante que
T(n) = O(n lgn)
37
Exerccio
Resolva a recorrncia
R(n) =
_
a se n = 1
2R(
n
2
) +b n se n = 2
1
, 2
2
, 2
3
, . . .
Soluo: R(n) = b nlgn +a n
Prova, por induo:
Base: se n = 1 ento R(n) = a e bnlgn +an = a
Passo: se n > 1 ento
R(n) = 2R(
n
2
) +b n
= 2
_
b
n
2
lg
n
2
+a
n
2
_
+b n
= b n(lgn 1) +a n +b n
= b nlgn b n +a n +b n
= b nlgn +a n
38
Exerccio
O algoritmo supe n 1 e devolve o valor de um elemento
mximo de A[1. . n]
MAX (A, n)
1 se n = 1
2 ento devolva A[1]
3 seno x MAX (A, n 1)
4 se x A[n]
5 ento devolva x
6 seno devolva A[n]
Anlise do desempenho:
tamanho de instncia: n
T(n): tempo de pior caso para instncia de tamanho n
39
T(n)
_
a se n = 1
T(n 1) +b se n = 2, 3, 4, 5, . . .
sendo a e b constantes
Teorema: T(n) a +b(n 1) para todo inteiro positivo n
Prova: . . .
Colorrio: T(n) = O(n)
Prova: . . .
40
Aula 5
Ordens e
Algoritmo Heapsort
41
Ordem
Denio: Dizemos que f = (g) se
existem constantes c > 0 e N > 0 tais que
f(n) c g(n) para todo n N
Exemplos:
n
2
= (n)
n
2
= (n
2
)
n
2
10n 100 = (n
2
)
nlgn = (n)
1.001
n
= (n
100
)
n no (n
2
)
f = (g) se e somente se g = O(f)
42
Ordem
Denio: Dizemos que f = (g) se
f = O(g) e f = (g)
Exemplos:
100n
2
= (n
2
)
n
2
10n 100 = (n
2
)
lgn = (lnn)
nlgn no (n
2
)
43
Novo algoritmo: Heapsort
Rearranja A[1. . n] em ordem crescente
HEAPSORT (A, n)
1 para i n/2 decrescendo at 1
2 faa MAX-HEAPIFY(A, n, i)
3 para m n decrescendo at 2
4 faa A[1] A[m]
5 MAX-HEAPIFY(A, m1, 1)
1 m n
66 44 55 44 22 33 11 77 88 99 99
Invariante: no incio de cada iterao
A[m+1. . n] grandes, ordem crescente
A[1. . m] pequenos, max-heap
44
Vetor A[1. . m]:
1
2 3
4 5 6 7
8 9 10 11 12 13 14 15
16 17 18 19 20 21 22 23 24 25 26 27 28 29
lho esquerdo do n i 2i
lho direito do n i 2i +1
pai do n i i/2
raiz (n 1) nvel 0
nvel do n i lgi
nvel p tem 2
p
ns
altura do n i lg
m
i

folha altura 0
A[1. . m] um max-heap se A[i/2] A[i] para cada i
45
MAX-HEAPIFY recebe A[1. . m] e i 1 tais que
subrvores com raiz 2i e 2i +1 so max-heaps.
Rearranja de modo que subrvore com raiz i seja max-heap.
MAX-HEAPIFY (A, m, i)
1 e 2i
2 d 2i +1
3 se e m e A[e] > A[i]
4 ento x e
5 seno x i
6 se d m e A[d] > A[x]
7 ento x d
8 se x ,= i
9 ento A[i] A[x]
0 MAX-HEAPIFY(A, m, x)
46
Aula 6
Algoritmo Heapsort (continuao)
Filas de prioridade
47
MAX-HEAPIFY recebe A[1. . m] e i 1 tais que
subrvores com raiz 2i e 2i +1 so max-heaps.
Rearranja de modo que subrvore com raiz i seja max-heap.
MAX-HEAPIFY (A, m, i)
1 e 2i
2 d 2i +1
3 se e m e A[e] > A[i]
4 ento x e
5 seno x i
6 se d m e A[d] > A[x]
7 ento x d
8 se x ,= i
9 ento A[i] A[x]
0 MAX-HEAPIFY(A, m, x)
Correto?
48
Desempenho de MAX-HEAPIFY, verso 1:
tamanho da instncia: altura do n i
h := lg
m
i

consumo de tempo no pior caso: T(h)
recorrncia: T(h) = T(h 1) +O(1)
mais concreto:
T(1) = a e T(h) = T(h 1) +b para h > 1
soluo: T(h) = bh b +a para h 1
resumo: T(h) = O(h)
como h lgm, podemos dizer que consumo O(lgm)
49
Desempenho de MAX-HEAPIFY, verso 2:
tamanho da instncia: nmero de ns na subrvore com raiz i
M

= m/i
consumo de tempo no pior caso: T(M)
recorrncia: T(M) T(2M/3) +O(1)
justicativa do 2/3. . .
mais concreto (a e b nmeros positivos):
T(1) = a e T(M) T(2M/3) +b para M > 1
soluo: T(M) b log
3/2
M +a
resumo: T(M) = O(lgM)
como M <
2m
i
2m, o algoritmo O(lgm)
50
Construo de um max-heap:
1 para i n/2 decrescendo at 1
2 faa MAX-HEAPIFY(A, n, i)
Invariante: no incio de cada iterao
i+1, . . . , n so razes de max-heaps
Desempenho:
consumo de tempo no pior caso: T(n)
T(n) =
n
2
O(lgn) = O(nlgn).
anlise mais cuidadosa: T(n) = O(n).
51
Prova de que a construo do heap consome O(n):
Para simplicar, suponha rvore completa e tem altura h
portanto n = 2
h+1
1, portanto
1
2
(n +1) = 2
h
cada n quantos
altura consome ns
1 1 2
h1
2 2 2
h2
3 3 2
h3
.
.
.
.
.
.
h h 2
0
1 2
h1
+2 2
h2
+. . . +h 2
0
_
1 2
1
+2 2
2
+. . . +h 2
h
_
2
h
_
1
1
2
1
+2
1
2
2
+. . . +h
1
2
h
+
_

1
2
(n +1)
1/2
(11/2)
2

1
2
(n +1)
n +1
52
Detalhes da prova:
x
0
+x
1
+x
2
+x
3
+ =
1
1 x
1x
0
+2x
1
+3x
2
+ =
1
(1 x)
2
1x
1
+2x
2
+3x
3
+ =
x
(1 x)
2
53
Consumo de tempo do Heapsort:
HEAPSORT (A, n)
1 para i n/2 decrescendo at 1 O(n)
2 faa MAX-HEAPIFY(A, n, i) O(n)
3 para m n decrescendo at 2 O(n)
4 faa A[1] A[m] O(n)
5 MAX-HEAPIFY(A, m1, 1) nO(lgn)
Total: O(nlgn)
Consumo de tempo no pior caso: (nlgn).
54
Fila de prioridades (priority queue)
Tipo abstrato de dados (= abstract data type)
1 m
A
Organizar A[1. . m] de modo que as operaes
consulte mximo
extraia mximo
aumenta valor de elemento
insira novo elemento
sejam ecientes
Vetor sem ordem alguma? crescente? decrescente?
55
Implementaes com max-heap
HEAP-MAXIMUM (A, m)
1 devolva A[1]
Consome O(1) unidades de tempo
HEAP-EXTRACT-MAX (A, m) m 1
1 max A[1]
2 A[1] A[m]
3 m m1
4 MAX-HEAPIFY(A, m, 1)
5 devolva max
Consomem O(lgm) unidades de tempo
56
HEAP-INCREASE-KEY (A, i, chave) chave A[i]
1 A[i] chave
2 enquanto i > 1 e A[i/2] < A[i]
3 faa A[i] A[i/2]
4 i i/2
No incio de cada iterao,
A[1. . m] um max-heap exceto talvez pela violao A[i/2] < A[i]
MAX-HEAP-INSERT (A, m, chave)
1 m m+1
2 A[m]
3 HEAP-INCREASE-KEY(A, m, chave)
Todos consomem O(lgm)
57
Aula 7
Quicksort
CLRS cap.7
58
Novo algoritmo: Quicksort
O algoritmo QUICKSORT rearranja A[p . . r] em ordem crescente
QUICKSORT (A, p, r)
1 se p < r
2 ento q PARTICIONE(A, p, r)
3 QUICKSORT(A, p, q 1)
4 QUICKSORT(A, q +1, r)
p q r
22 22 22 11 11 44 88 99 88 99 88
No comeo da linha 3, A[p . . q1] A[q] A[q+1. . r]
59
PARTICIONE rearranja o vetor de modo que p q r e
A[p . . q1] A[q] < A[q+1. . r]
PARTICIONE (A, p, r)
1 x A[r] x o piv
2 i p 1
3 para j p at r 1
4 faa se A[j] x
5 ento i i +1
6 A[i] A[j]
7 A[i +1] A[r]
8 devolva i +1
Invariantes: no comeo de cada iterao
A[p . . i] x A[i+1. . j1] > x A[r] = x
p i j r
22 22 22 88 88 88 11 99 11 99 44
60
Consumo de tempo de PARTICIONE
consumo de tempo: (n) unidades de tempo
Consumo de tempo do QUICKSORT
o algoritmo O(n
2
)
o algoritmo (nlgn)
como veremos adiante
61
Exemplos exploratrios
se PARTICIONE divide sempre n/2paran/2
ento T(n) = 2T(n/2) +(n)
donde T(n) = (nlgn)
se PARTICIONE divide n/10para9n/10
ento T(n) = T(n/10) +T(9n/10) +(n)
done T(n) = (nlgn)
se PARTICIONE divide 0paran1
ento T(n) = T(n 1) +(n)
done T(n) = (n
2
)
62
Desempenho do QUICKSORT no pior caso
P(n): consumo de tempo no pior caso
P(n) max
0k<n
_
P(k) +P(nk1)
_
+(n)
cota superior: P(n) = O(n
2
)
prova?
em lugar de uma prova, vou examinar um exemplo concreto
63
Exemplo concreto:
S(0) = S(1) = 1 e
S(n) = max
0k<n
_
S(k) +S(nk1)
_
+n para n 2
n S(n)
0 1
1 1
2 1 +1 +2 = 4
3 1 +4 +3 = 8
4 1 +8 +4 = 13
Vou provar que S(n) n
2
+1 para n 0
Prova:
se n 1 ento . . . trivial
se n 2 ento . . .
64
se n 2 ento
S(n) = max
0k<n
_
S(k) +S(nk1)
_
+n
hi
max
_
k
2
+1 +(nk1)
2
+1
_
+n
= (n 1)
2
+2 +n CLRS 7.4-3
= n
2
n +3
n
2
+1
Exerccio (CLRS 7.4-1): S(n)
1
2
n
2
para todo n 1
65
Desempenho do QUICKSORT no melhor caso
M(n): consumo de tempo no melhor caso
M(n) min
0k<n
_
M(k) +M(nk1)
_
+(n)
cota inferior: M(n) = (nlgn)
prova? CLRS 7.4-2
66
Quicksort aleatorizado
PARTICIONE-ALE (A, p, r)
1 i RANDOM(p, r)
2 A[i] A[r]
3 devolva PARTICIONE(A, p, r)
QUICKSORT-ALE (A, p, r)
1 se p < r
2 ento q PARTICIONE-ALE(A, p, r)
3 QUICKSORT-ALE(A, p, q 1)
4 QUICKSORT-ALE(A, q +1, r)
Consumo de tempo esperado (ou seja, mdio): (nlgn)
67
Aula 8
i-simo menor elemento
Mediana
CLRS cap.9
68
Novo problema: i-simo menor elemento
Problema: Encontrar o i-simo menor elemento de A[p . . r]
Suponha A[p . . r] sem elementos repetidos
Uma instncia: 33 o 4-o menor elemento
22 99 32 88 34 33 11 97 55 66 A
11 22 32 33 34 55 66 88 97 99 ordenado
Mediana:
n+1
2
-simo menor
69
Observaes:
problema s tem soluo se i est no intervalo 1. . n
caso i = 1: algoritmo O(n)
caso i = 2: algoritmo O(n)
mediana: algoritmo O(nlgn)
i arbitrrio: algoritmo O(nlgn)
existe algo melhor?
70
Algoritmo: Recebe vetor A[p . . r] (elementos todos diferentes)
e i no intervalo 1 . . rp+1
e devolve i-simo menor elemento
SELECT (A, p, r, i)
1 se p = r
2 ento devolva A[p]
3 q PARTICIONE(A, p, r)
4 k q p +1
5 se k = i
6 ento devolva A[q]
7 se k > i
8 ento devolva SELECT(A, p, q 1, i)
9 seno devolva SELECT(A, q +1, r, i k)
p q r
. . . .
k 1 n k
71
Consumo de tempo
proporcional ao nmero de compraes entre elementos de A
todas as comparaes acontecem no PARTICIONE
PARTICIONE(A, p, r) faz n 1 comparaes
T(n): nmero comparaes entre elementos de A no pior caso
T(n) = T(n 1) +n1
soluo: T(n) = (n
2
)
caso mdio?
72
EXEMPLO
Nmero mdio de comparaes no pior caso
Examina todas as pertmutaes 1, 2, . . . , n
Supe linha 6 no se aplica e linhas 89 escolhem o lado maior
A[p . . r] comps
1,2 1+0
2,1 1+0
mdia 2/2
A[p . . r] comps
1,2,3 2+1
2,1,3 2+1
1,3,2 2+0
3,1,2 2+0
2,3,1 2+1
3,2,1 2+1
mdia 16/6
73
A[p . . r] comps
1,2,3,4 3+3
2,1,3,4 3+3
1,3,2,4 3+2
3,1,2,4 3+2
2,3,1,4 3+3
3,2,1,4 3+3
1,2,4,3 3+1
2,1,4,3 3+1
1,4,2,3 3+1
4,1,2,3 3+1
2,4,1,3 3+1
4,2,1,3 3+1
A[p . . r] comps
1,3,4,2 3+1
3,1,4,2 3+1
1,4,3,2 3+1
4,1,3,2 3+1
3,4,1,2 3+1
4,3,1,2 3+1
2,3,4,1 3+3
3,2,4,1 3+3
2,4,3,1 3+2
4,2,3,1 3+2
3,4,2,1 3+3
4,3,2,1 3+3
mdia 116/24
Mais um caso: quando r p +1 = 5, a mdia 864/120
74
Esperana (nmero mdio) de comparaes
E[T(n)] = ?
notao: E(n) := E[T(n)]
probab de que A[p . . q] tenha exatamente k elementos:
1
n
recorrncia:
E(n) n1 +
n
k=1
1
n
E
_
max(k 1, n k)
_
n1 +
2
n
_
E(
n
2
) +E(
n
2
+1) + +E(n1)
_
soluo: E(n)
?
= O(n)
75
Implementao: SELECT-ALEATORIZADO
troque PARTICIONE por PARTICIONE-ALEATORIZADO
nmero esperado de comparaes:
E(1) = 0
E(n) n1 +
2
n
_
E(
n
2
) + +E(n1)
_
para n 2
alguns valores:
n E(n)

=
1 0 0
2 2/2 1
3 16/6 2.7
4 116/24 4.8
5 864/120 7.2
compare com EXEMPLO acima
76
Teorema: E(n) 4n para todo inteiro n 1
Prova:
se n = 1 ento E(n) = E(1) = 0 4 = 4 1 = 4n
se n > 1 ento E(n) n 1 +
2
n
_
E(
n
2
) + +E(n1)
_
n 1 +
2
n
_
4
n
2
+ +4(n1)
_
< 4n 1
< 4n
Conra, pois as contas no batem com as do livro!
77
Corolrio: E(n) = O(n)
78
Aula 9
rvores binrias de busca
Programao dinmica:
nmeros de Fibonacci e
multiplicao de cadeia de matrizes
CLRS cap.12, cap.15
79
rvores binrias de busca
rvores binrias:
vetor rvore binria
vetor crescente rvore binria de busca
busca binria em vetor busca binria em lista encadeada
Estrutura:
n x
chave[x]
pai: p[x]
lhos: esq[x] e dir[x]
valor especial NIL
80
rvore de busca: para todo n x
para todo y na subrvore esquerda de x
e todo n z na subrvore direita de x
chave[y] chave[x] chave[z]
81
Varredura esquerda-raiz-direita:
imprime os ns da subrvore que tem raiz x
VARREDURA-E-R-D (x) inorder traversal
1 se x ,= NIL
2 ento VARREDURA-E-R-D(esq[x])
3 imprima chave[x]
4 VARREDURA-E-R-D(dir[x])
rvore de busca
varredura erd d chaves em ordem crescente
tamanho da instncia: nmero de ns na subrvore de raiz x
notao: n
consumo de tempo: T(n) = T(k) +T(n k 1) +(1)
para algum 0 k n 1
T(n) = (n)
82
Tipo abstrato de dados
operaes: busca, mnimo, mximo, sucessor, predecessor,
insero, remoo
todas consomem O(h), sendo h a altura da rvore
83
BUSCA-EM-RVORE (x, k) Tree-Search
1 se x = NIL ou k = chave[x]
2 ento devolva x
3 se k < chave[x]
4 ento BUSCA-EM-RVORE(esq[x], k)
5 seno BUSCA-EM-RVORE(dir[x], k)
MIN-DE-RVORE (x) Tree-Minimum
1 enquanto esq[x] ,= NIL
2 faa x esq[x]
3 devolva x
84
SUCESSOR-EM-RVORE (x) Tree-Successor
1 se dir[x] ,= NIL
2 ento devolva MIN-DE-RVORE(dir[x])
3 y p[x]
4 enquanto y ,= NIL e x = dir[y]
5 faa x y
6 y p[y]
7 devolva y
INSERO-EM-RVORE?
REMOO-EM-RVORE?
Todas as operaes consomem O(h)
sendo h a altura da rvore
rvore balanceada: h = O(lgn) sendo n o nmero de ns
85
Programao dinmica
recursocomtabela
transformao inteligente de recurso em iterao
Exemplos:
nmeros de Fibonacci
rvore tima de busca (CLRS sec.15.2)
multiplicao de cadeias de matrizes
subseqncia comum mxima
mochila booleana
Aqui, a palavra programao no tem nada a ver com
programao de computadores
86
Problema 1: nmeros de Fibonacci
F
0
= 0 F
1
= 1 F
n
= F
n1
+F
n2
Algoritmo recursivo:
FIBO-REC (n)
1 se n 1
2 ento devolva n
3 seno a FIBO-REC(n 1)
4 b FIBO-REC(n 2)
5 devolva a +b
Consumo de tempo proporcional ao nmero de somas:
T(0) = T(1) = 0
T(n) = T(n 1) +T(n 2) +1 se n 2
87
Soluo: T(n) 3
n
/2
n
para n 6
Consumo exponencial: T(n) =
_
(
3
2
)
n
_
Por que to ineciente?
Algoritmo resolve a mesma subinstncia muitas vezes:
F
5
/ \
F
4
F
3
/ \ / \
F
3
F
2
F
2
F
1
/ \ / \ / \
F
2
F
1
F
1
F
0
F
1
F
0
88
Fibonacci via programao dinmica
FIBO (n)
1 f[0] 0
2 f[1] 1
3 para i 2 at n
4 faa f[i] f[i 1] +f[i 2]
5 devolva f[n]
Tabela f[0. . n1]
Consumo de tempo: (n)
89
Problema 2: multiplicao de cadeias de matrizes
se A p q e B q r ento AB p r
(AB)[i, j] =

k
A[i, k] B[k, j]
nmero de multiplicaes escalares = p q r
Multiplicao em cadeia: A
1
A
2
A
3
10
A
1
100
A
2
5
A
3
50
((A
1
A
2
) A
3
) 7500 mults escalares
(A
1
(A
2
A
3
)) 75000 mults escalares
90
Problema: Encontrar nmero mnimo de
multiplicaes escalares necessrio para
calcular produto A
1
A
2
A
n
p
0
p
1
p
2
. . . p
n1
p
n
A
1
A
2
. . . A
n
cada A
i
p
i1
p
i
Continua. . .
91
Aula 10
Programao dinmica:
Multiplicao de cadeia de matrizes
Subset sum (= soma de cheques)
CLRS cap.15
92
Programao dinmica
Problema 2: multiplicao de cadeia de matrizes
se A p q e B q r ento AB p r
(AB)[i, j] =

k
A[i, k] B[k, j]
nmero de multiplicaes escalares = p q r
Multiplicao em cadeia: A
1
A
2
A
3
10
A
1
100
A
2
5
A
3
50
((A
1
A
2
) A
3
) 7500 mults escalares
(A
1
(A
2
A
3
)) 75000 mults escalares
93
Problema: Encontrar nmero mnimo de multiplicaes escalares
necessrio para calcular produto A
1
A
2
A
n
p
0
p
1
p
2
. . . p
n1
p
n
A
1
A
2
. . . A
n
cada A
i
p
i1
p
i
Passo 1: Estrutura recursiva do problema
Solues timas contm solues timas: se
(A
1
A
2
) (A
3
((A
4
A
5
)A
6
))
minimiza multiplicaes ento
(A
1
A
2
) e (A
3
((A
4
A
5
)A
6
))
tambm minimizam
94
Passo 2: Algoritmo recursivo:
recebe p
i1
, . . . , p
j
com i j e devolve nmero mnimo de
multiplicaes escalares
REC-MAT-CHAIN (p, i, j)
1 se i = j
2 ento devolva 0
3 x
4 para k i at j 1 faa
5 a REC-MAT-CHAIN(p, i, k)
6 b REC-MAT-CHAIN(p, k +1, j)
7 q a +p
i1
p
k
p
j
+b
8 se q < x
9 ento x q
0 devolva x
tamanho de uma instncia: n := j i +1
consumo de tempo: (2
n
)
demora tanto porque mesma instncia resolvida muitas vezes
95
Passo 3: Programao dinmica
m[i, j] = nmero mnimo de multiplicaes escalares
para calcular A
i
A
j
decomposio: (A
i
A
k
) (A
k+1
A
j
)
recorrncia:
se i = j ento m[i, j] = 0
se i < j ento m[i, j] = min
ik<j
_
m[i, k] +p
i1
p
k
p
j
+m[k+1, j]
_
Exemplo: m[3, 7] = min
3k<7
m[3, k] +p
2
p
k
p
7
+m[k+1, 7]
96
cada instncia A
i
A
j
resolvida uma s vez
em que ordem calcular os componentes da tabela m?
para calcular m[2, 6] preciso de
m[2, 2], m[2, 3], m[2, 4], m[2, 5] e de
m[3, 6], m[4, 6], m[5, 6], m[6, 6]
1 2 3 4 5 6 7 8 j
1 0
2 0 ?
3 0
4 0
5 0
6 0
7 0
8 0
i
97
Calcule todos os m[i, j] com j i +1 = 2,
depois todos com j i +1 = 3,
depois todos com j i +1 = 4,
etc.
98
Programao dinmica: recebe p
0
, p
1
, . . . , p
n
e devolve m[1, n]
MATRIX-CHAIN-ORDER(p, n)
1 para i 1 at n faa
2 m[i, i] 0
3 para l 2 at n faa
4 para i 1 at n l +1 faa
5 j i +l 1
6 m[i, j]
7 para k i at j 1 faa
8 q m[i, k] +p
i1
p
k
p
j
+m[k+1, j]
9 se q < m[i, j]
0 ento m[i, j] q
1 devolva m[1, n]
compare com REC-MAT-CHAIN
linhas 410 tratam das subcadeias A
i
A
j
de comprimento l
um dos invariantes menos importantes: j i +1 = l
99
Prova da correo do algoritmo:
estrutura recursiva (optimal substructure property)
(veja slide 93)
Consumo de tempo:
tamanho de uma instncia: n := j i +1
obviamente (n
3
)
(trs loops encaixados)
100
Programao dinmica
Problema 3: Subset sum (soma de cheques)
Problema: Dados inteiros no-negativos w
1
, . . . , w
n
, W
encontrar K 1, . . . , n tal que

kK
w
k
= W
Uma instncia: w = 100, 30, 90, 35, 40, 30, 10 e W = 160
motivao: problema dos cheques
algum subconj dos cheques w
1
, . . . , w
n
tem soma W?
soluo fora-bruta:
examine todos os 2
n
subconjuntos de 1, . . . , n
101
Algoritmo recursivo (ineciente)
devolve 1 se instncia tem soluo e 0 em caso contrrio
REC (w, n, W)
1 se W = 0
2 ento devolva 1
3 se n = 0
4 ento devolva 0
5 se REC(w, n 1, W) = 1
6 ento devolva 1
7 se w
n
> W
8 ento devolva 0
9 seno devolva REC(w, n1, Ww
n
)
102
depende da subestrutura tima (optimal substructure property):
se K soluo da instncia (n, W) ento
se n K ento
K n soluo da instncia (n 1, W w
n
)
se n / K ento
K soluo da instncia (n 1, W)
Consumo de tempo:
(2
n
) (Prova?)
demora tanto porque mesma instncia resolvida muitas vezes
103
Algoritmo de programao dinmica
s[i, Y ] :=
1 se instncia (i, Y ) tem soluo
0 caso contrrio
Recorrncia: s[i, 0] = 1
s[0, Y ] = 0 se Y > 0
s[i, Y ] = s[i 1, Y ] se w
i
> Y
s[i, Y ] = max
_
s[i 1, Y ], s[i 1, Y w
i
]
_
0 1 2 3 4
0 0 0 0 0 0
1
2
3
4 ?
5
colunas: Y vai de 0 a W
linhas: i vai de 0 a n
lembrete: W e w
1
, . . . , w
n
so inteiros!
104
SUBSET-SUM(w, n, W)
0 aloca s[0. . n, 0. . W]
1 para i 0 at n faa
2 s[i, 0] 1
3 para Y 1 at W faa
4 s[0, Y ] 0
5 para i 1 at n faa
6 s[i, Y ] s[i1, Y ]
7 se s[i, Y ] = 0 e w
i
Y
8 ento s[i, Y ] s[i1, Y w
i
]
9 devolva s[n, W]
cada instncia (i, Y ) resolvida uma s vez
105
Prova da correo:
propriedade da subestrutra tima
Consumo de tempo:
obviamente (nW)
Exerccio:
escreva uma verso que devolva K tal que

kK
w
k
= W
106
Resumo do projeto do algoritmo
passo 1: encontrar a propridade da subestrutura tima
(optimal substructure property)
passo 2: escrever algoritmo recursivo
passo 3: transformar algoritmo em programao dinmica
107
Comentrios sobre o consumo de tempo do algoritmo
Algoritmo consome tempo (nW)
A dependncia de W m notcia:
se multiplicar w
1
, . . . , w
n
, W por 100
a instncia continua essencialmente a mesma
mas o algoritmo consome 100 vezes mais tempo!
Qual o tamanho de uma instncia w
1
, . . . , w
n
, W do problema?
muito razovel dizer que o tamanho n +1
infelizmente, no d pra escrever (nW) como funo de n +1
porque nW envolve o valor (e no s o tamanho) do W
a denio de tamanho deveria levar em conta o valor de W
e no apenas a presena de W
outro detalhe: necessrio denir o tamanho por dois nmeros
adote o par (n, W) como tamanho de uma instncia
ento (nW) funo do tamanho
108
mas (n, W) no a denio ideal de tamanho:
se multiplicarmos w
1
, . . . , w
n
, W por 100
a instncia continua essencialmente a mesma
mas o seu tamanho passa de (n, W) a (n, 100W),
o que no razovel!
denio razovel de tamanho de um nmero (como W, por exemplo):
nmero de caracteres
exemplo: o tamanho do nmero 256877 6 (e no 256877)
concluso: tamanho de instncia w
1
, . . . , w
n
, W (n, log(W+1))
o consumo de tempo de SUBSET-SUM (n2
logW
)
o algoritmo considerado exponencial
veja m da pgina
www.ime.usp.br/~pf/analise_de_algoritmos/aulas/mochila.html
109
Aula 11
Programao dinmica:
subseqncia comum mxima
CLRS sec.15.4
110
Problema: Subseqncia comum mxima
Denio:
z
1
, . . . , z
k
) subseqncia de x
1
, . . . , x
m
) se
existem ndices i
1
< < i
k
tais que
z
1
= x
i
1
, z
2
= x
i
2
, . . . , z
k
= x
i
k
Uma instncia:
5, 9, 2, 7) subseqncia de 9, 5, 6, 9, 6, 2, 7, 3)
111
Pequenas observaes:
x
1
, . . , x
m
) o mesmo que x[1. . m]
x
j
o mesmo que x[j]
no bom escrever Z X
112
Exerccio preliminar:
Decidir se z
1
, . . . , z
k
) subseqncia de x
1
, . . . , x
m
)
Uma instncia:
A A A subseq de B A B B A B B B A A B B A B A B A B B ?
Soluo gulosa:
SUB-SEQ (z, k, x, m)
0 i k
1 j m
2 enquanto i 1 e j 1 faa
3 se z
i
= x
j
4 ento i i 1
5 j j 1
6 se i 1
7 ento devolva no
8 seno devolva sim
Prove que o algoritmo est correto!
113
Problema: Encontrar uma subseqncia comum mxima
de seqncias X e Y
Z subseq comum de X e Y se Z subseq de X e de Y
minha abreviatura: ssco = subseqncia comum
abreviatura do livro: LCS = longest common subsequence
uma instncia (g 15.6 de CLRS):
X A B C B D A B
Y B D C A B A
ssco B C A
ssco maximal A B A
ssco mxima B C B A
outra ssco mxima B D A B
114
invente heurstica gulosa para o problema
mostre que ela no resolve o problema
115
Algoritmo de programao dinmica
Problema simplicado:
encontrar o comprimento de uma sscomx de X e Y
c[i, j] = comprimento de uma sscomx de X
i
e Y
j
Recorrncia:
c[0, j] = c[i, 0] = 0
c[i, j] = c[i1, j1] +1 se i, j > 0 e x
i
= y
j
c[i, j] = max
_
c[i, j1], c[i1, j]
_
se i, j > 0 e x
i
,= y
j
116
LCS-LENGTH (X, m, Y, n)
0 aloca c[0. . m, 0. . n]
1 para i 0 at m faa
2 c[i, 0] 0
3 para j 1 at n faa
4 c[0, j] 0
5 para i 1 at m faa
6 para j 1 at n faa
7 se x
i
= y
j
8 ento c[i, j] c[i 1, j 1] +1
9 seno se c[i 1, j] c[i, j 1]
10 ento c[i, j] c[i 1, j]
11 seno c[i, j] c[i, j 1]
12 devolva c[m, n]
117
horizontal: X = A B C B D A B
vertical: Y = B D C A B A
0 1 2 3 4 5 6
B D C A B A
0 0 0 0 0 0 0 0
1 A 0
2 B 0
3 C 0
4 B 0
5 D 0
6 A 0
7 B 0
118
0 1 2 3 4 5 6
B D C A B A
0 0 0 0 0 0 0 0
1 A 0 0
2 B 0
3 C 0
4 B 0
5 D 0
6 A 0
7 B 0
118-a
0 1 2 3 4 5 6
B D C A B A
0 0 0 0 0 0 0 0
1 A 0 0 0
2 B 0
3 C 0
4 B 0
5 D 0
6 A 0
7 B 0
118-b
0 1 2 3 4 5 6
B D C A B A
0 0 0 0 0 0 0 0
1 A 0 0 0 0
2 B 0
3 C 0
4 B 0
5 D 0
6 A 0
7 B 0
118-c
0 1 2 3 4 5 6
B D C A B A
0 0 0 0 0 0 0 0
1 A 0 0 0 0 1
2 B 0
3 C 0
4 B 0
5 D 0
6 A 0
7 B 0
118-d
0 1 2 3 4 5 6
B D C A B A
0 0 0 0 0 0 0 0
1 A 0 0 0 0 1 1 1
2 B 0
3 C 0
4 B 0
5 D 0
6 A 0
7 B 0
118-e
0 1 2 3 4 5 6
B D C A B A
0 0 0 0 0 0 0 0
1 A 0 0 0 0 1 1 1
2 B 0 1 1 1 1 2 2
3 C 0
4 B 0
5 D 0
6 A 0
7 B 0
118-f
0 1 2 3 4 5 6
B D C A B A
0 0 0 0 0 0 0 0
1 A 0 0 0 0 1 1 1
2 B 0 1 1 1 1 2 2
3 C 0 1 1 2 2 2 2
4 B 0 1 1 2 2 3 3
5 D 0 1 2 2 2 3 3
6 A 0 1 2 2 3 3 4
7 B 0 1 2 2 3
118-g
0 1 2 3 4 5 6
B D C A B A
0 0 0 0 0 0 0 0
1 A 0 0 0 0 1 1 1
2 B 0 1 1 1 1 2 2
3 C 0 1 1 2 2 2 2
4 B 0 1 1 2 2 3 3
5 D 0 1 2 2 2 3 3
6 A 0 1 2 2 3 3 4
7 B 0 1 2 2 3 4
118-h
0 1 2 3 4 5 6
B D C A B A
0 0 0 0 0 0 0 0
1 A 0 0 0 0 1 1 1
2 B 0 1 1 1 1 2 2
3 C 0 1 1 2 2 2 2
4 B 0 1 1 2 2 3 3
5 D 0 1 2 2 2 3 3
6 A 0 1 2 2 3 3 4
7 B 0 1 2 2 3 4 4
118-i
Z = z
1
, . . . , z
k
), X = x
1
, . . . , x
m
), Y = y
1
, . . . , y
n
)
notao: X
i
:= x
1
, . . . , x
i
)
propriedade da subestrutura tima:
suponha Z sscomx de X e Y
se x
m
= y
n
ento z
k
= x
m
= y
n
e Z
k1
sscomx de X
m1
e Y
n1
se x
m
,= y
n
e z
k
,= x
m
ento Z sscomx de X
m1
e Y
se x
m
,= y
n
e z
k
,= y
n
ento Z sscomx de X e Y
n1
Prove a propriedade!
119
Exemplo da propriedade da subestrutura tima:
X A B C B D A B
Y B D C A B A
ssco mxima B C B A
outra ssco mxima B D A B
120
Consumo de tempo:
tamanho de instncia o par (m, n)
linha 7 (se x
i
= y
j
) executada mn vezes
consumo de tempo: O(mn)
121
Aula 12
Algoritmos gulosos
O problema do disquete
CLRS cap 16
122
Algoritmos gulosos
Algoritmo guloso
em cada iterao, acrescenta soluo
o objeto que parece melhor naquele momento
procura maximal e acaba obtendo mximo
procura timo local e acaba obtendo timo global
Costuma ser
muito simples e intuitivo
muito eciente
difcil provar que est correto
Problema precisa ter
subestrutura tima (como na programao dinmica)
propriedade da escolha gulosa (greedy-choice property)
123
O problema do disquete
Instncias v=1 da mochila booleana
Problema: Dados inteiros no-negativos w
1
, . . . , w
n
e W
encontrar K 1, . . . , n mximo tal que

kK
w
k
W
Diferente do subset sum dos slides 101106
Motivao: gravao de arquivos em um disquete
Problema simplicado: encontrar [K[ mximo
124
Algoritmo guloso, verso recursiva:
dado I 1, . . . , n o algoritmo devolve [K[
sendo K subconjunto mximo de I tal que

kK
w
k
W
DISQUETE-REC (w, W, I)
1 se I =
2 ento devolva 0
3 escolha m em I tal que w
m
= minw
i
: i I
4 se w
m
> W
5 ento devolva 0
6 seno devolva 1 +DISQUETE-REC(w, W w
m
, I m)
125
escolha gulosa (greedy-choice property):
se w
m
= minw
1
, . . . , w
n
e w
m
W
ento m pertence a alguma soluo tima
subestrutura tima (optimal substructure property):
se K soluo tima da instncia (n, W) e n K
ento K n soluo tima para (n 1, W w
n
)
A prova das propriedades muito fcil!
126
Verso melhor de DISQUETE-REC:
supe w
1
w
n
DISQUETE-REC (w, n, W)
1 se n = 0 ou w
n
> W
2 ento devolva 0
3 seno devolva 1 +DISQUETE-REC(w, n 1, W w
n
)
Consumo de tempo:
tamanho de uma instncia: n
recorrncia: T(n) = T(n 1) +O(1)
soluo: T(n) = O(n)
127
Verso iterativa, supondo w
1
w
n
:
DISQUETE-IT(w, n, W)
1 k 0
2 para j n decrescendo at 1 faa
3 se w
j
> W
4 ento devolva k
5 seno k k +1
6 W W w
j
7 devolva k
Consumo de tempo: O(n)
Programao dinmica consumiria (n
2
)
128
Aula 13
Algoritmos gulosos:
problema dos intervalos disjuntos
CLRS sees 16.1, 16.2 e 16.3
129
Problema: coleo disjunta mxima de intervalos
Problema: Dados intervalos [s
1
, f
1
), . . . , [s
n
, f
n
)
encontrar uma coleo mxima de intervalos disjuntos dois a dois
Instncia:
s
1
f
1
Soluo (subconjunto de 1, . . . , n):
Intervalos i e j so disjuntos se f
i
s
j
ou f
j
s
i
130
Outra instncia:
i 1 2 3 4 5 6 7 8 9 10 11
s
i
1 3 0 5 3 5 6 8 8 2 12
f
i
4 5 6 7 8 9 10 11 12 13 14
um candidato a soluo: 3, 9, 11
uma soluo tima: 1, 4, 8, 11
131
A estrutura gulosa do problema
Propriedade da escolha gulosa:
se f
m
mnimo ento m est em alguma soluo tima
Propriedade da subestrutura tima:
se A soluo tima e m A tal que f
m
mnimo
ento A m soluo tima de j : s
j
f
m
(todos os intervalos posteriores a f

m
)
Propriedade mais geral da subestrutura tima:
se A soluo tima e A m
ento A m soluo tima de i : f
i
s
m
j : s
j
f
m
(intervalos anteriores a s
m
ou posteriores a f
m
)
Prove as propriedades!
132
Algoritmo guloso, verso recursiva:
dado I 1, . . . , n
o algoritmo devolve subconjunto mximo A de I tal que
os intervalos [s
a
, f
a
), a A, so disjuntos dois a dois
INTERV-DISJ-REC (s, f, I) supe I ,=
1 se [I[ = 1
2 ento devolva I
3 seno escolha m em I tal que f
m
= minf
i
: i I
4 J j I : s
j
f
m
5 A INTERV-DISJ-REC(s, f, J)
6 devolva m A
prova da correo: escolha gulosa + subestrutura tima
133
Verso recursiva mais eciente:
no precisa administrar o conjunto I explicitamente
supe f
1
f
n
Algoritmo devolve uma subcol disjunta mx de [s
k
, f
k
) : s
k
f
h
INTERV-DISJ-REC(s, f, h)
1 m h +1
2 enquanto m n e s
m
< f
h
3 faa m m+1
4 se m > n
5 ento devolva
6 seno devolva m INTERV-DISJ-REC(s, f, m)
Para resolver problema original
adote f
0
:= e diga INTERV-DISJ-REC(s, f, 0)
134
Algoritmo guloso, verso iterativa:
supe f
1
f
n
INTERVALOS-DISJUNTOS (s, f, n) supe n 1
1 A 1
2 i 1
3 para m 2 at n faa
4 se s
m
f
i
5 ento A A m
6 i m
7 devolva A
Nome do algoritmo no CLRS: Greedy-Activity-Selector
A organizao do algoritmo semelhante do PARTICIONE
135
Consumo de tempo:
consumo de tempo: (n)
136
Minha primeira verso de INTERVALOS-DISJUNTOS
era correta e eciente, mas deselegante:
INTERVALOS-DISJUNTOS-FEIO (s, f, n)
1 A
2 i 1
3 enquanto i n faa
4 A A i
5 m i +1
6 enquanto m n e s
m
< f
i
faa
7 m m+1
8 i m
9 devolva A
Mostre que consumo de tempo O(n)
(apesar dos dois loops)
137
Aula 14
Algoritmos gulosos:
cdigos de Human
CLRS seo 16.3
138
Cdigos de Human
Trata de compresso de dados e combina vrias
idias/tcnicas/estruturas:
gula
la de prioridades
rvores binrias
139
texto = seqncia de caracteres
cada caracter representado por uma seq de bits
cdigo de um caracter = seq de bits
nmero de bits por caracter pode ser varivel
exemplo: a = 0, b = 101, etc.
cdigo livre de prexos
fcil codicao/decodicao: 01010101101 = ababb
Dado um arquivo (= seqncia de caracteres) c
1
, . . . , c
n
), com
c
i
C para todo i
Cada c em C ocorre f[c] vezes no arquivo
Problema:
Encontrar uma codicao de caracteres em seqs de bits
que minimize o comprimento do arquivo codicado
140
Exemplo:
caracter c . . . . . . . . . . . . . . . . . . . a b c d e f
freqncia f[c] . . . . . . . . . . . . . . . 45 13 12 16 9 5
cdigo de comprimento xo . . 000 001 010 011 100 101
cdigo de comprimento varivel 0 101 100 111 1101 1100
se texto original tem 100 caracteres, texto codicado ter
300 bits se cdigo de comprimento xo
224 bits se cdigo de comprimento varivel
141
tabela de cdigo representada por rvore binria
rvore binria cheia: cada n tem 0 ou 2 lhos
caracteres so as folhas
0 se desce para esquerda, 1 se desce para direita
d(c) := profundidade de folha c na rvore
d(c) = nmero de bits de caracter c
custo da rvore :=

c
f[c] d(c)
texto codicado ter

c
f[c] d(c) bits
Problema reformulado: encontrar rvore de custo mnimo
142
exemplos:
. .
/ \
0/ \1 / \
/ \ a .
/ \ / \
. . / \
/ \ / . .
/ \ / / \ / \
. . . c b . d
/ \ / \ / \ / \
a b c d e f f e
143
Algoritmo guloso:
Recebe conjunto C de caracteres e vetor de freqncias f
constroi rvore do cdigo e devolve raiz da rvore
HUFFMAN (C, f)
0 Q C
1 para i 1 at [C[ 1 faa
2 x EXTRACT-MIN(Q)
3 y EXTRACT-MIN(Q)
4 aloque novo n z
5 esq[z] x
6 dir[z] y
7 chave[z] chave[x] +chave[y]
8 INSERT(Q, z)
9 devolva EXTRACT-MIN(Q)
Q la de prioridades
EXTRACT-MIN retira de Q um n q com chave[q] mnima
144
Detalhamento da linha 0 de HUFFMAN:
INICIALIZA-RVORE (C)
1 para cada c em C faa
2 aloque novo n z
3 esq[z] dir[z] NIL
4 chave[z] f[c]
5 INSERT(Q, z)
145
Desempenho de HUFFMAN:
instncia: (C, f)
tamanho de instncia: n := [C[
inicializao da rvore: n vezes INSERT
n 1 vezes: EXTRACT-MIN, EXTRACT-MIN, INSERT
cada EXTRACT-MIN e cada INSERT consome O(lgn)
total: O(nlgn)
146
Prova da correo de HUFFMAN:
Propriedade da escolha gulosa: se x e y minimizam f
ento existe rvore tima em que x e y so folhas-irms
Prova:
sejam a e b so folhas-irms de profundidade mxima
suponha f[x] f[y] e f[a] f[b]
troque x com a:
custo(T) custo(T
) =
c
f[c]d(c)
c
f[c]d
(c)
= f[x]d(x) +f[a]d(a) f[x]d
(x) f[a]d
(a)
= f[x]d(x) +f[a]d(a) f[x]d(a) f[a]d(x)
= (f[a] f[x]) (d(a) d(x))
0
agora troque y com b
147
Propriedade da subestrutura tima:
suponha que x e y minimizam f
e T uma rvore tima que tem x e y como folhas-irms;
seja z o pai de x, y em T
e dena C
:= C x, y z e f
[z] := f[x] +f[y];

ento T
:= T x, y +z rvore tima para (C
, f
)
Prova:
custo(T) = custo(T
) +f[x] +f[y]
. . .
148
Aula 15
Union/Find:
conjuntos disjuntos dinmicos
CLRS sees 21.1, 21.2 e 21.3
149
ADT de conjuntos disjuntos dinmicos
ADT = abstract data type = estrutura de dados abstrata
= conjunto de coisas mais repertrio de operaes sobre as coisas
Nossas coisas: conjuntos mutuamente disjuntos
Exemplo:
a b c d e
une b, d
a b, d c e
une c, e
a b, d e, c
une c, d
a b, d, c, e
une e, d
a b, d, c, e
Cada objeto (como b, por exemplo) pertence a um nico conjunto
150
Operaes de nossa ADT:
FINDSET (x) qual dos conjuntos contm x?
UNION (x, y) unir o conjunto que contm x ao que contm y
MAKESET (x) construir conjunto x
Como dar nomes aos conjuntos?
por exemplo, que nome dar ao conjunto b, d?
resposta: cada conjunto tem um representante
151
Seqncia de operaes MAKESET, UNION, FINDSET:
M M M
. .
n
U F U U F U F F F U F
. .
m
Diversas estruturas de dados poderiam ser usadas:
vetor indexado pelos objetos
uma lista ligada por conjunto
etc.
vamos usar disjoint-set forest
152
Estrutura de dados disjoint-set forest:
cada n x tem um pai pai [x]
isso dene um conjunto de rvores
cada conjunto de objetos uma das rvores
cada rvore tem uma raiz r denida por pai [r] = r
a raiz de uma rvore o representante do conjunto
Nossa meta: tempo total O(m)
= tempo amortizado O(1) por operao
As rvores so diferentes das que vimos at agora:
no tm ponteiros para lhos
um n pode ter qualquer nmero de lhos
153
Implementaes bsicas
FINDSET devolve a raiz da rvore que contm x
FINDSET-ITER (x)
1 enquanto pai [x] ,= x
2 faa x pai [x]
3 devolva x
verso recursiva:
FINDSET-REC (x)
1 se pai [x] = x
2 ento devolva x
3 seno devolva FINDSET-REC(pai [x])
154
UNION (x, y)
1 x
FINDSET(x)
2 y
FINDSET(y)
3 pai [x
] y
MAKESET(x)
1 pai [x] x
155
Exemplo:
01 para i 1 at 16
02 faa MAKESET(x
i
)
03 para i 1 at 15 em passos de 2
04 faa UNION(x
i
, x
i+1
)
05 para i 1 at 13 em passos de 4
06 faa UNION(x
i
, x
i+2
)
07 UNION(x
1
, x
5
)
08 UNION(x
11
, x
13
)
09 UNION(x
1
, x
10
)
10 FINDSET(x
2
)
11 FINDSET(x
9
)
156
Exemplo:
0 para i 1 at 9
1 faa MAKESET(x
i
)
2 UNION(x
1
, x
2
)
3 UNION(x
3
, x
4
)
4 UNION(x
4
, x
5
)
5 UNION(x
2
, x
4
)
6 UNION(x
6
, x
7
)
7 UNION(x
8
, x
9
)
8 UNION(x
8
, x
6
)
9 UNION(x
5
, x
7
)
157
Consumo de tempo: MAKESET O(1)
UNION O(n)
FINDSET O(n)
M M M
. .
n
. .
m
Tempo total: nO(1) +mO(n) +mO(n) = O(mn)
Ainda est longe da meta de O(m) . . .
158
Melhoramento 1: union by rank
MAKESETUR (x)
1 pai [x] x
2 rank[x] 0
UNIONUR (x, y) supe x e y em rvores diferentes
1 x
FINDSET(x)
2 y
FINDSET(y)
3 se rank[x
] = rank[y
]
4 ento pai [y
] x
5 rank[x
] rank[x
] +1
6 seno se rank[x
] > rank[y
]
7 ento pai [y
] x
8 seno pai [x
] y
159
Exerccio: rank[x] a altura do n x
(altura = mais longo caminho de x at uma folha)
Fato importante: rank[x] lgn
x
,
sendo n
x
o nmero de ns na rvore que contm x
(n
x
no o nmero de ns da subrvore com raiz x)
Concluso: todo caminho de um n at uma raiz
tem comprimento lgn
160
Exemplo:
0 para i 1 at 9
1 faa MAKESETUR(x
i
)
2 UNIONUR(x
2
, x
1
)
3 UNIONUR(x
4
, x
3
)
4 UNIONUR(x
5
, x
4
)
5 UNIONUR(x
4
, x
2
)
6 UNIONUR(x
7
, x
6
)
7 UNIONUR(x
9
, x
8
)
8 UNIONUR(x
6
, x
8
)
9 UNIONUR(x
7
, x
5
)
161
Consumo de tempo da verso com union by rank:
MAKESETUR O(1)
UNIONUR O(lgn)
FINDSET O(lgn)
M M M
. .
n
. .
m
Tempo total: O(mlgn)
Ainda est longe de O(m) . . .
162
Melhoramento 2: union by rank + path compression
A funo devolve a raiz da rvore que contm x
depois de fazer com que x e seus ancestrais se tornem lhos da raiz
FINDSETPC (x)
1 se x ,= pai [x]
2 ento pai [x] FINDSETPC(pai [x])
3 devolva pai [x]
Cdigo de UNIONURPC:
troque FINDSET por FINDSETPC em UNIONUR
163
Outra maneira de escrever o cdigo:
FINDSETPC (x)
1 se x = pai [x]
2 ento devolva x
3 seno pai [x] FINDSETPC(pai [x])
4 devolva pai [x]
164
Exemplo:
0 para i 1 at 9
1 faa MAKESETUR(x
i
)
2 UNIONURPC(x
2
, x
1
)
3 UNIONURPC(x
4
, x
3
)
4 UNIONURPC(x
5
, x
4
)
5 UNIONURPC(x
4
, x
2
)
6 UNIONURPC(x
7
, x
6
)
7 UNIONURPC(x
9
, x
8
)
8 UNIONURPC(x
6
, x
8
)
9 UNIONURPC(x
7
, x
5
)
repita com UNIONURPC(x
5
, x
7
) no lugar da linha 9
165
Consumo de tempo com union by rank + path compression:
MAKESETUR, UNIONURPC, FINDSETPC
M M M
. .
n
. .
m
tempo total: O(m lg
n)
prova difcil
custo amortizado de uma operao: O(lg
n)
tudo se passa como se todo caminho tivesse comprm lg
n
166
lg
n o nico nmero natural k tal que T(k 1) < n T(k)

sendo T(0) = 1 e T(k) = 2
T(k1)
para todo k
Exemplo: T(4) = 2
2
2
2
= 2
(2
(2
2
)
)
k T(k)
0 2
0
= 1
1 2
1
= 2
2 2
2
= 4
3 2
4
= 16
4 2
16
= 65536
5 2
65536
observe que lgT(k) = T(k 1) para k = 1, 2, 3, . . .
portanto lg
n o menor k tal que lg lg . . . lg

. .
k
n 1
167
n lg
n
1 0
2 1
3 1
4 2
5 2
.
.
.
.
.
.
15 2
16 3
.
.
.
.
.
.
65535 3
65536 4
.
.
.
.
.
.
100000000000000000 000000000000
. .
4
80 .
.
.
.
.
.
168
lg
n cresce to devagar que quase O(1)

quase atingimos nossa meta de O(m)
CLRS usa funo (n) que cresce ainda mais devagar que lg
n
169
Aula 16a
Grafos
e rvores
CLRS cap. 23
170
Grafos
Um grafo um par (V, E) de conjuntos tal que E V
(2)
V
(2)
o conj dos pares no-ordenados de elementos de V
V
(2)
o conj dos pares u, v com u V , v V , u ,= v
0 [E[
1
2
[V [ ([V [ 1) < [V [
2
os elementos de V so chamados vrtices
os elementos de E so chamados arestas
notao simplicada para aresta: (u, v) ou uv
vrtices u e v so vizinhos ou adjacentes se uv aresta
171
Exemplo de grafo:
V = a, b, c, d, e, f, g, h, i
E = a, b, b, c, c, d, d, e, . . . , i, c
notao simplicada:
E = ab, bc, cd, de, ef, fg, gh, ha, bh, cf, ci, df, ig, ih, ic
172
Conexo e componentes:
um grafo conexo se, para cada par x, y em V ,
existe caminho de x a y
fato: se (V, E) conexo ento [E[ [V [ 1
a recproca verdadeira?
um componente de um grafo um
pedao conexo maximal do grafo
G conexo sse G tem apenas 1 componente
173
Grafos: estrutura recursiva
Dentro de todo grafo h outros grafos
Subgrafo de G = (V, E):
X V e F X
(2)
se F E ento (X, F) subgrafo de G
exemplo: um componente
exemplo: mapa das ruas de Campinas subgrafo
do mapa completo (ruas e estradas) do estado SP
174
Contrao de G = (V, E):
partio . de V e subconjunto T de .
(2)
suponha (X, E X
(2)
) conexo para cada X em .
suponha que X, Y em T sse
existe x, y em E tal que x X e y Y
ento (., T) contrao de G
exemplo: a coleo dos componentes de G
(cada componente um vrtice da contrao)
exemplo: mapa das estradas do estado de SP contrao
do mapa completo (ruas e estradas) do estado
contrao um tipo especial de um minor (minor, em ingls)
175
Exemplo importante de contrao: o grafo G/uv
uv E
. := u, v x : x V u, v
T induzido por E da maneira bvia
(., T) uma contrao de G
notao: G/uv
veja CLRS seo B.4, p.1084
176
Clculo de componentes
Problema: Encontrar o nmero de componentes de um grafo G
COMPONENTS-REC (G)
0 V V [G]
0 E E[G]
1 se E =
2 ento devolva [V [
3 seja uv um elemento de E
4 devolva COMPONENTS-REC (G/uv)
Como implementar G/uv de maneira eciente?
Resposta: estrutura oresta de conjuntos disjuntos
cada rvore da estrutura um bloco da partio da V
177
Verso iterativa (convm escrever (V, E) no lugar de G):
COMPONENTS (V, E)
1 para cada v em V faa
2 MAKESET(v)
3 c [V [
4 para cada (u, v) em E faa
5 se FINDSET(u) ,= FINDSET(v)
6 ento UNION(u, v)
7 c c 1
8 devolva c
Use MAKESETUR, UNIONURPC e FINDSETPC
178
tamanho de instncia: ([V [, [E[)
temos V operaes MAKESET
seguidas de E operaes UNION e FINDSET
consumo de tempo: O(([V [ +[E[) lg
[V [)
para simplicar, escreva O((V +E) lg
V )
se V = O(E) ento consumo ser O(E lg
V )
179
Aula 16b
rvores geradoras de peso mnimo
e o algoritmo de Kruskal
CLRS cap. 23
180
rvores
Uma rvore um tipo especial de grafo:
uma rvore um grafo conexo (V, A) tal que [A[ = [V [ 1
rvores so minimamente conexas
rvores no tm os conceitos raiz, pai, lho
(V, A) rvore sse (V, A) conexo e no tem ciclos
181
rvore geradora de um grafo G = (V, E):
uma rvore geradora de G
uma rvore (V, A) que subgrafo de G
denio alternativa: uma rvore geradora de G
um subconjunto A de E tal que (V, A) rvore
G tem uma rvore geradora sse G conexo
182
Problema da rvore geradora mnima
Problema: Dado grafo (V, E) com pesos nas arestas
encontrar uma rvore geradora de peso mnimo
em ingls: minimum spanning tree ou MST
cada aresta uv tem um peso w(uv) (nmero real)
claro que w(vu) = w(uv)
o peso de A E w(A) :=

uvA
w(uv)
uma rvore geradora (V, A) tima se tem peso mnimo
aplicao: pavimentao barata de rede de estradas
183
Exerccio: Discuta o seguinte algoritmo guloso:
1 A
2 para cada v em V faa
3 F e : e = xv E
4 seja f uma aresta de peso mnimo em F
5 A A f
6 devolva A
184
Algoritmo de Kruskal: av de todos os algoritmos gulosos
MST-KRUSKAL-REC (G, w) supe G conexo
1 se E[G] =
2 ento devolva G tem 1 s vrtice
3 escolha uv em E[G] que tenha w mnimo
4 w
CONTRAI-PESOS (G, uv, w)

5 A MST-KRUSKAL-REC(G/uv, w
)
6 devolva uv A
Na linha 4, CONTRAI-PESOS devolve w
denida assim:
para toda aresta XY de G/uv
w
(XY ) = minw(xy) : xy E[G], x X, y Y

Minha discusso do algoritmo de Kruskal um pouco diferente da do CLRS
185
Prova de que o algoritmo est correto:
propriedade da escolha gulosa:
se aresta uv minimiza w
ento uv pertence a alguma rvore tima
se T rvore tima de G e uv aresta de T
ento T/uv rvore tima de G/uv
186
Como implementar G/uv e w
de maneira eciente?
Resposta: oresta de conjuntos disjuntos
MST-KRUSKAL (V, E, w) supe (V, E) conexo
1 A
2 para cada v em V
3 faa MAKESET(v)
4 coloque E em ordem crescente de w
5 para cada uv E em ordem crescente de w
6 faa se FINDSET(u) ,= FINDSET(v)
7 ento A A uv
8 UNION(u, v)
9 devolva A
use MAKESETUR, UNIONURPC, FINDSETPC
que acontece se grafo no for conexo?
187
Consumo de tempo do algoritmo MST-KRUSKAL:
linha por linha:
linha consumo
23 O(V )
4 O(E lgE)
5 O(E)
6 O(E lg
V )
7 O(E)
8 O(E lg
V )
como [V [ 1 [E[, consumo O(E lgE)
como [E[ < [V [
2
, consumo O(E lgV )
Concluso: poderia usar FINDSET no lugar de FINDSETPC
188
Aulas 1718
rvore geradora de peso mnimo:
algoritmo de Prim
CLRS cap. 23
189
Problema da rvore geradora mnima
Problema: Dado grafo (V, E) com pesos nas arestas
Verso simplicada: encontrar o peso de uma rvore geradora
de peso mnimo
Para descrever algoritmo de Prim precisamos de dois conceitos:
um corte um par (S, S) de subconjuntos de V
sendo S := V S
uma aresta uv cruza um corte (S, S)
se u S e v S ou vice-versa
190
Exerccio: Discuta o seguinte algoritmo guloso abaixo
O algoritmo supe que E =: e
1
, . . . , e
m
e w(e
1
) w(e
m
)
1 A
2 seja r um vrtice qualquer
3 S r
4 para i 1 at m faa
5 se e
i
cruza o corte (S, S)
6 ento A A e
i
7 seja u
i
a ponta de e
i
em S
8 S S u
i
9 devolva A
191
Idia do algoritmo de Prim:
no comeo de cada iterao, temos uma rvore (S, A)
que subgrafo de (V, E)
cada iterao escolhe uma aresta de peso mnimo
dentre as que cruzam o corte (S, S)
Prova de que o algoritmo est correto:
propriedade da escolha gulosa:
se aresta uv tem peso mnimo dentre as que cruzam um corte
ento uv pertence a alguma rvore tima
se T rvore tima de G e uv aresta de T
ento T/uv rvore tima de G/uv
192
Rascunho 1 do algoritmo de Prim
RASCUNHO-1 (V, E, w) supe grafo conexo
1 escolha qualquer r em V
2 S r
3 peso 0
4 enquanto S ,= V faa
5 min
6 para cada e em E faa
7 se e cruza (S, S) e min > w(e)
8 ento min w(e)
9 seja u
a ponta de e em S
10 S S u
11 peso peso +min

12 devolva peso
193
bloco de linhas 59:
escolhe uma aresta de peso mnimo
dentre as que cruzam corte (S, S)
prova da correo do algoritmo:
no incio de cada iterao,
o conjunto de arestas (implicitamente) escolhidas
parte de alguma rvore geradora tima
194
Consumo de tempo do RASCUNHO-1:
linha consumo
13 O(1)
45 O(V )
610 O(V E)
11 O(V )
12 O(1)
consumo total: O(V E)
consumo muito alto. . .
195
Novidades:
para simplicar, vamos usar matriz simtrica W no lugar de w
W[u, v] :=
w(uv) se uv aresta
caso contrrio
como se o grafo fosse completo
cada vrtice v tem uma chave[v]
igual ao peso de uma aresta mnima
dentre as que ligam v a S
196
RASCUNHO-2 (V, W, n) supe grafo conexo
2 S r
3 para cada u em V r faa
4 chave[u] W[r, u]
5 peso 0
6 enquanto S ,= V faa
7 min
8 para cada u em V S faa
9 se min > chave[u]
10 ento min chave[u]
11 u
u
12 S S u
13 peso peso +chave[u
]
14 para cada v em V S faa
15 se chave[v] > W[v, u
]
16 ento chave[v] W[v, u
]
17 devolva peso
197
Observaes:
no comeo de cada iterao
chave[u] = minW[s, u] : s S
para cada u em V S
no comeo da linha 12
min = minW[s, u] : s S e u V S
198
Consumo de tempo do RASCUNHO-2:
linha consumo
15 O(V )
67 O(V )
811 O(V
2
)
1213 O(V )
1416 O(V
2
)
consumo total: O(V
2
)
melhor que O(V E), mas ainda alto. . .
lembrete: [V [ 1 [E[ < [V [
2
199
Novidades:
listas de adjacncia no lugar da matriz W
Adj [u] a lista dos vrtices vizinhos a u
V S armazenado numa la de prioridades Q
com prioridades dadas por chave
Q pode ser implementada como um min-heap
(mas h outras possibilidades)
200
RASCUNHO-3 (V, Adj , w) supe grafo conexo
1 para cada u em V faa
2 chave[u]
4 para cada u em Adj [r] faa
5 chave[u] w(ru)
6 peso 0
7 Q FILA-PRIORIDADES (V r, chave)
8 enquanto Q ,= faa
9 u EXTRAI-MIN(Q)
10 peso peso +chave[u]
11 para cada v em Adj [u] faa
12 se v Q e chave[v] > w(vu)
13 ento DECREMENTE-CHAVE(Q, chave, v, w(vu))
14 devolva peso
201
Detalhes:
FILA-PRIORIDADES (U, chave) constri la de prioridades
com conjunto de elementos U e
prioridades dadas por chave
(por exemplo, um min-heap)
DECREMENTE-CHAVE(Q, chave, v, w(vu))
faz chave[v] w(vu) e
faz os ajustes necessrios na estrutura de Q
202
Consumo de tempo do RASCUNHO-3
supondo que la de prioridades um min-heap:
consumo na linha 7: O(V )
consumo na linha 9: O(V lgV )
consumo nas linhas 1112: O(E)
pois

v
[Adj [v][ = 2[E[ (mtodo agregado de anlise)
consumo na linha 13: O(E lgV )
consumo nas demais linhas: O(V )
total: O(V lgV +E lgV )
como [E[ [V [ 1, total O(E lgV )
203
Novidade:
rvore inicial no tem vrtices
no rascunho anterior rvore inicial era (r, )
204
RASCUNHO-4 (V, Adj , w) supe grafo conexo
1 para cada u em V faa
2 chave[u]
4 chave[r] 0
5 peso 0
6 Q FILA-PRIORIDADES (V, chave)
7 enquanto Q ,= faa
8 u EXTRAI-MIN(Q)
9 peso peso +chave[u]
11 se v Q e chave[v] > w(vu)
13 devolva peso
Consumo de tempo: O(E lgV )
assintoticamente, o tempo necessrio par ordenar as E arestas
205
Algoritmo de Prim: verso nal
Novidades:
devolve uma rvore geradora tima
poderia devolver conjunto A de arestas de rvore tima,
mas melhor devolver um vetor de predecessores
206
MST-PRIM (V, Adj , w) supe grafo conexo
1 para cada vrtice u faa
2 chave[u]
3 [u] NIL
5 chave[r] 0
6 Q FILA-PRIORIDADES (V, chave)
7 enquanto Q ,= faa
8 u EXTRAI-MIN(Q)
10 se v Q e chave[v] > w(uv)
12 [v] u
13 devolva
Consumo de tempo: O(E lgV )
207
Qual das 5 verses do algoritmo mais eciente?
precisamos comparar O(V E) com O(V
2
) com O(ElgV )
qual a melhor?
depende da relao entre E e V
208
Lies que desenvolvimento do algoritmo de Prim ensina:
a idia do algoritmo simples
mas a implementao eciente no trivial
tamanho de instncias medido por dois nmeros (E e V )
que no so independentes (V 1 E < V
2
)
uma implementao pode ser melhor quando E prximo de V
2
outra implementao pode ser melhor quando E longe de V
2
boa implementao depende de
boa estrutura de dados para grafos
209
Estruturas de dados para grafos
Representao de grafos:
podemos supor V = 1, 2, 3, . . . , n
matriz de adjacncias: M[u, v] vale 1 ou 0
listas de adjacncia: lista encadeada Adj [u] para cada u V
Estrutura de dados para rvore geradora:
adota uma raiz para a rvore
cada n u exceto a raiz ter um pai [u]
o conjunto de arestas da rvore ser ([u], u) : v V r
210
Aula 19a
Ordenao em tempo linear
CLRS sec. 8.2 8.3
211
Ordenao por contagem
Problema: Encontrar uma permutao crescente de A[1. . n]
sabendo que cada A[j] est em 0, . . . , k
Exemplo:
2 2 1 0 1 2 2 1 2 0 0 0 1 2 2 1
212
Algoritmo rearranja A[1. . n] em ordem crescente
supondo que A[j] 0, . . . , k para cada j:
COUNTING-SORT (A, n, k)
1 para i 0 at k
2 faa C[i] 0
3 para j 1 at n
4 faa C[A[j]] C[A[j]] +1
5 para i 1 at k
6 faa C[i] C[i] +C[i 1]
7 para j n decrescendo at 1
8 faa B[C[A[j]]] A[j]
9 C[A[j]] C[A[j]] 1
10 para j 1 at n
11 faa A[j] B[j]
213
1 j n
A
B
0 i k
C
Entre linhas 4 e 5, C[i] := [m : A[m] = i[
Entre linhas 6 e 7, C[i] := [m : A[m] i[
Invariante: antes de cada execuo da linha 8, para cada i,
C[i] := [m : A[m] < i[ + [m : m j e A[m] = i[
214
Consumo de tempo do COUNTING-SORT:
linha consumo na linha
12 (k)
34 (n)
56 (k)
79 (n)
1011 (n)
Consumo total: (n +k)
se k constante (no depende de n) ento consumo (n)
se k = O(n) ento consumo (n)
A propsito: COUNTING-SORT estvel
215
Ordenao digital (radix sort)
Problema: Rearranjar A[1. . n] em ordem crescente
sabendo que cada A[j] tem d dgitos decimais
A[j] = a
d
a
2
a
1
= a
d
10
d1
+ +a
2
10
1
+a
1
10
0
Exemplo: 329 457 657 839 436 720 355
216
Exemplo:
329 720 720 329
457 355 329 355
657 436 436 436
839 457 839 457
436 657 355 657
720 329 457 720
355 839 657 839
Algoritmo rearranja A[1. . n] em ordem crescente:
RADIX-SORT (A, n, d)
1 para i 1 at d faa 1 at d e no o contrrio!
2 ordene A[1. . n] usando apenas dgito i como chave
essencial que a ordenao na linha 2 seja estvel
217
Consumo de tempo:
se usar COUNTING-SORT, tempo ser (d n)
218
Aula 19b
Limite inferior (lower bound)
para o problema da ordenao
CLRS sec. 8.1
219
Ordenao: limite inferior
Problema: Rearranjar A[1. . . n] em ordem crescente
existem algoritmos O(nlgn)
existe algoritmo assintoticamente melhor?
depende
todo algoritmo baseado em comparaes (nlgn)
prova?
qualquer algoritmo de comparaes uma rvore de deciso
220
Exemplo:
INSERTIONSORT (A, n)
1 para j 2 at n faa
2 chave A[j]
3 i j 1
5 A[i +1] A[i]
6 i i 1
7 A[i +1] chave
rvore de deciso para A = [a, b, c], elementos distintos
a : b representa comparao entre a e b
bac signica que b < a < c
qquer execuo do algoritmo caminho da raiz at folha
221
rvore de deciso:
a : b
>
b : c a : c
/ \ / \
abc a : c bac b : c
/ \ / \
acb cab bca cba
222
rvore de deciso para um algoritmo que ordena A[1. . n]:
cada folha uma permutao de 1, . . . , n
todas as n! permutaes devem estar presentes
quantas de comparaes, no pior caso?
resposta: altura, h, da rvore
concluso: devemos ter 2
h
n!
(n!)
2
=

n1
i=0
(i+1)(ni)

n1
i=0
n = n
n
n! n
n/2
h lg(n!) lg(n
n/2
)
1
2
nlgn
223
Concluso:
Todo algoritmo de ordenao baseado em comparaes faz
(nlgn)
comparaes no pior caso
224
Exerccio: Qual o invariante na linha 8 do RADIX-SORT?
Exerccio: Suponha que todos os elementos do vetor A[1. . n]
pertencem ao conjunto 1, 2, . . . , n
3
. Escreva um algoritmo que
rearranje A[1. . n] o vetor em ordem crescente em tempo O(n).
Exerccio: Faa rvore deciso para algoritmo SELSORT aplicado a
A[1. . 4].
Exerccio: Mostre que qualquer algoritmo baseado em
comparaes necessita de pelo menos n 1 comparaes para
decidir se n nmeros dados so todos iguais.
Exerccio: Dadas seqncias estritamente crescentes a
1
, . . . , a
n
) e
b
1
, . . . , b
n
), queremos ordenar a seqncia a
1
, . . . , a
n
, b
1
, . . . , b
n
).
Mostre que 2n 1 comparaes so necessrias, no pior caso, para
resolver o problema.
225
Aula 20
Complexidade de problemas:
introduo informal
s classes P e NP
CLRS cap. 34
226
Introduo complexidade de problemas
At aqui, tratamos de problemas no varejo
Agora vamos trabalhar no atacado
227
Alguns exemplos de problemas computacionais
Raiz quadrada:
dado um inteiro positivo n, encontrar um inteiro positivo x
tal que x
2
= n ou constatar que tal x no existe
Equao do segundo grau:
dados inteiros a, b, c, encontrar um inteiro x tal que
ax
2
+bx +c = 0 ou constatar que tal x no existe
Equao diofantina:
dada equao polinomial com nmero arbitrrio de variveis
(como x
3
yz +2y
4
z
2
7xy
5
z = 6, por exemplo)
encontrar valores das variveis que satisfaam a equao
ou constatar que tais valores no existem
228
Fatorao:
dado um nmero natural n > 1, encontrar naturais p > 1 e q > 1
tais que n = p q ou constatar que tal par no existe
MDC:
encontrar o maior divisor comum de inteiros positivos p e q
Fator comum grande:
dados inteiros positivos p, q e k, encontrar
divisor comum d de p e q tal que d k
ou constatar que tal divisor no existe
Subseqncia crescente mxima:
encontrar uma subseqncia crescente mxima
de uma seqncia dada de inteiros positivos
229
Subseqncia crescente longa:
dado inteiro positivo k e seqncia de inteiros positivos,
encontrar uma subseqncia crescente de comprimento k
ou constatar que uma tal subseq no existe
Intervalos disjuntos:
encontrar uma subcoleo disjunta mxima
de uma coleo de intervalos dada
Disquete:
dados inteiros positivos w
1
, . . . , w
n
e W, encontrar
subconj mximo J de 1, . . . , n tal que

jJ
w
j
W
Subset sum:
1
, . . . , w
n
e W, encontrar
J 1, . . . , n tal que

jJ
w
j
= W
230
rvore geradora de peso mnimo:
dado um grafo com peso nas arestas,
ou constatar que o grafo no tem rvore geradora
rvore geradora de peso mximo: . . .
Caminho mnimo:
dados vrtices u e v de um grafo,
encontrar um caminho de comprimento mnimo de u a v
ou constatar que no existe caminho de u a v
Caminho curto:
dados vrtices u e v de um grafo e um nmero k,
encontrar um caminho de u a v de comprimento k
ou constatar que tal caminho no existe
Caminho mximo: . . .
231
Ciclo mnimo:
dado um grafo, encontrar ciclo com nmero mnimo de arestas
ou constatar que o grafo no tem ciclo
Ciclo longo:
dado um grafo e um nmero k,
encontrar ciclo simples de comprimento k
ou constatar que tal ciclo no existe
Ciclo hamiltoniano:
dado um grafo, encontrar um ciclo simples
que passe por todos os vrtices
ou constatar que tal ciclo no existe
Emparelhamento que cobre um lado de grafo bipartido:
dado um grafo com bipartio (U, V ),
encontrar um emparelhamento que cubra U
ou constatar que tal emparelhamento no existe
232
Observaes sobre a lista de problemas:
vrios tipos de problemas:
de busca, de maximizao, de minimizao, etc.
vrios dos problemas envolvem grafos
em geral, nem todas as instncias tm soluo
aparncias enganam:
problemas com enunciado semelhante
podem ser muito diferentes
alguns problemas so casos particulares de outros
233
Problemas polinomiais e a classe P
algoritmo resolve problema se, para qualquer instncia,
d resposta certa
ou constata que a instncia no tem soluo
algoritmo polinomial se
existe j tal que consumo de tempo O(N
j
)
sendo N o tamanho da instncia
problema polinomial se
existe algoritmo polinomial para o problema
classe P: todos os problemas polinomiais
d um exemplo de problema fora de P
compare com a prova do lower bound (nlgn) da ordenao
234
Complexidade de problemas
questo: quo fcil o problema A?
resposta: existe algoritmo polinomial para A
questo: quo difcil o problema A?
resposta: no existe algoritmo polinomial para A
prova de existncia versus prova de no-existncia
para a maioria dos problemas
no sei fazer nem uma coisa nem outra
no sei o problema est em P ou fora de P
que fazer?
235
Complexidade relativa de problemas
conceito de complexidade relativa:
problema B mais difcil que problema A
problema A mais fcil que problema B
exemplo: problema A subproblema de B
em geral: reduo polinomial entre problemas (veja adiante)
antes de tratar de redues,
preciso restringir a classe de problemas
no d pra tratar de todo e qualquer problema. . .
236
Problemas razoveis e a classe NP
um problema razovel se
fcil reconhecer uma soluo do problema
quando se est diante de uma
para toda instncia I do problema
possvel vericar, em tempo polinomial,
se uma suposta soluo da instncia I uma soluo de I
a maioria dos problemas da lista acima razovel
problema razovel

= pertence classe NP
no confunda NP com no-polinomial
daqui em diante, s trataremos de problemas em NP
237
A questo P = NP?
evidente: P NP
ningum mostrou ainda que P ,= NP
ser que P = NP?
238
Apndice: certicados de inexistncia de soluo
se um problema no tem soluo
como certicar isso?
certicado de inexistncia de soluo
diferena entre certicar e resolver
exemplos:
raiz quadrada, eq do segundo grau, col disj de intervalos,
caminho de u a v, ciclo hamiltoniano, etc.
certicados de maximalidade
exemplos: MDC, etc.
239
Aulas 2122
Complexidade computacional:
problemas de deciso,
as classes NP e NPC
CLRS cap. 34
240
P, NP e NP-completo
antes de denir P e NP
preciso padronizar o tipo de problemas
padronizao: s problemas de deciso
problema de deciso: toda instncia tem resposta SIM ou NO
SIM / NO

= tem soluo / no tem soluo
instncia positiva . . . SIM
instncia negativa . . . NO
a teoria s trata de problemas de deciso
241
Exemplos de problemas de deciso
EQ-SEGUNDO-GRAU:
dados inteiros a, b, c, decidir se existe um inteiro x
tal que ax
2
+bx +c = 0
NMERO-COMPOSTO:
dado um nmero natural n > 1,
decidir se existem naturais p > 1 e q > 1 tais que n = p q
NMERO-PRIMO:
decidir se um dado natural n > 1 primo
Note os problemas complementares
242
Mais exemplos de problemas de deciso
INTERV-DISJS:
dada coleo de intervalos e natural k,
decidir se existe subcoleo disjunta com k intervalos
SUBSEQ-CRESC-LONGA:
dado inteiro positivo k e seqncia de inteiros positivos,
decidir se alguma subseqncia crescente tem comprimento k
SUBSET-SUM:
1
, . . . , w
n
e W,
decidir se existe J 1, . . . , n tal que

jJ
w
j
= W
EMPARELH-BIPARTIDO:
dado um grafo com bipartio (U, V ),
decidir se existe um emparelhamento que cobre U
243
HAM-CYCLE:
decidir se um grafo dado tem um ciclo hamiltoniano
LONG-CYCLE:
dado um grafo G e um natural k,
decidir se G tem um ciclo simples de comprimento k
CLIQUE:
decidir se G tem uma clique com k vrtices
INDEPENDENT-SET:
decidir se G tem um conjunto independente com k vrtices
244
CLIQUE-COVER:
decidir se os vertices de G podem se cobertos por k cliques
245
Problemas de deciso no so to fracos assim:
suponha que HAM-CYCLE(G) tem resposta SIM
como encontrar ciclo hamiltoniano num grafo G?
para cada aresta e
se HAM-CYCLE(Ge) tem resposta SIM
ento G Ge
G ciclo hamiltoniano
246
Mais padronizao
instncia: cadeias de caracteres
tamanho de uma instncia: comprimento da cadeia
Conseqncias:
tamanho de um nmero W logW
o tamanho de um vetor A[1. . n]

n
i=1
logA[i]
247
Exemplo:
PRIMO (n)
1 para i n 1 decrescendo at 2 faa
2 se i divide n
3 ento devolva "NO"
4 devolva "SIM"
Qual o tamanho de uma instncia?
O algoritmo polinomial?
248
Classe P
todos os problemas de deciso
que podem ser resolvidos por algoritmos polinomiais
Antes de denir a classe NP, preciso do conceito certicado
249
Certicado de problema de deciso
certicado: uma prova de que resposta SIM est certa
certicado substitui o conceito de soluo
tamanho do certicado:
limitado por polinmio no tamanho da instncia
exemplos de certicados:
eq do segundo grau
col disj de intervalos
caminho de u a v
ciclo hamiltoniano
etc.
250
Algoritmo vericador para um problema de deciso:
recebe instncia I e candidato C a certicado
e devolve SIM ou NO ou no pra
se instncia I positiva
ento existe C que faz vericador devolver SIM
em tempo polinomial no tamanho de I
se instncia I negativa
ento no existe C que faa vericador devolver SIM
Certicado polinomial:
certicado para o qual existe algoritmo vericador
251
Classe NP
cujas instncias positivas tm certicados polinomiais
grosseiramente: problema NP

= problema razovel
252
Problemas complementares e certicado de NO
problema complementar: troque SIM por NO
certicado de SIM de um problema =
certicado de NO do complementar
exemplos:
RAIZ-QUADRADA e seu complemento
EMPARELH-BIPARTIDO e conjunto de Hall
SUBSEQ-CRESC-LONGA e cobert por subseqs estrit descresc
INTERV-DISJS e cobertura por cliques de intervalos
NMERO-PRIMO e NMERO-COMPOSTO
253
Classe co-NP
cujos complementos esto em NP
cujas instncias negativas tm certicados polinomiais
254
Relao entre P, NP e co-NP
fcil: P NP e P co-NP
ningum sabe ainda: P
?
= NP
255
Redues polinomiais entre problemas em NP
Reduo polinomial de problema X a problema Y :
algoritmo que transforma instncias de X em instncias de Y
transforma instncias positivas em positivas e
negativas em negativas
consome tempo polinomial no tamanho das instncias de X
Notao: X
P
Y
algor reduo) + algor polin para Y ) = algor polin para X)
Reduo mostra que
X to fcil quanto Y
Y to difcil quanto X
256
Exemplos de reduo:
RAIZ-QUADRADA
P
EQ-SEGUNDO-GRAU
INTERV-DISJS
P
INDEPENDENT-SET
HAM-CYCLE
P
LONG-CYCLE
HAM-PATH
P
HAM-CYCLE
HAM-CYCLE
P
HAM-PATH
CLIQUE
P
INDEPENDENT-SET
INDEPENDENT-SET
P
CLIQUE
HAM-CYCLE
P
INDEPENDENT-SET
257
Problemas completos em NP
problema Y NP-completo se
1. Y NP e
2. X
P
Y para todo X em NP
NP-completo

= to difcil qto qquer problema em NP
classe NPC: todos os problemas NP-completos
evidente: P = NP sse P NPC ,=
teorema de Cook & Levin: NPC no vazio
258
Dado problema X
eu gostaria de dizer que X P ou que X / P
mas em geral s consigo dizer que X P ou que X NPC
Livro de Garey e Johnson
259
Exemplos de problemas em NPC:
SUBSET-SUM
MOCHILA
HAM-CYCLE
LONG-CYCLE
LONG-PATH
CLIQUE
INDEPENDENT-SET
CLIQUE-COVER
etc.
260
Aula 23
Anlise amortizada
Tabelas dinmicas
CLRS cap. 17
261
Anlise amortizada
Contexto:
repertrio de operaes
seqncia de n operaes do repertrio
algumas operaes so caras
mas muitas so baratas e compensam as caras
quero calcular o custo total C da seq de ops
262
Mais detalhes:
i-sima op tem um custo (= consumo de tempo) c
i
quero calcular custo total C :=

n
i=1
c
i
clculo da soma pode ser difcil
imagine custo ctcio constante c por operao
tal que C

n
i=1
c = c n
c o custo amortizado de uma operao
Aqui, custo = tempo
263
Anlise amortizada: mtodo contbil
Exemplo: Contador binrio
A
5 4 3 2 1 0
0 0 0 0 0 0
0 0 0 0 0 1
0 0 0 0 1 0
0 0 0 0 1 1
0 0 0 1 0 0
0 0 0 1 0 1
0 0 0 1 1 0
0 0 0 1 1 1
0 0 1 0 0 0
0 0 1 0 0 1
em vermelho: bits que mudam de valor quando somo 1
264
k1 3 2 1 0
INCREMENT (A, k)
1 i 0
2 enquanto i < k e A[i] = 1
3 faa A[i] 0
4 i i +1
5 se i < k
6 ento A[i] 1
custo = tempo = nmero de bits alterados k
265
Seqncia de n chamadas de INCREMENT:
INCR INCR INCR INCR INCR
. .
n
custo total nk
a estimativa exagerada
vou mostrar que custo total n
vou mostrar que custo amortizado de uma operao 1
266
Exemplo com k = 6 e n = 16:
A
5 4 3 2 1 0
0 0 0 0 0 0
0 0 0 0 0 1
0 0 0 0 1 0
0 0 0 0 1 1
0 0 0 1 0 0
0 0 0 1 0 1
0 0 0 1 1 0
0 0 0 1 1 1
0 0 1 0 0 0
0 0 1 0 0 1
0 0 1 0 1 0
0 0 1 0 1 1
0 0 1 1 0 0
0 0 1 1 0 1
0 0 1 1 1 0
0 0 1 1 1 1
0 1 0 0 0 0
267
A[0] muda n vezes
A[1] muda n/2 vezes
A[2] muda n/4 vezes
A[3] muda n/8 vezes
etc.
custo total:
lgn
i=0
_
n
2
i
_
< n
i=0
1
2
i
= 2n
Como podemos calcular esse 2n de maneira mais fcil?
268
Mtodo contbil de anlise:
c
i
= custo real da i-sima operao
c
i
= custo amortizado (ctcio) da i-sima operao
dena c
i
de modo que

i
c
i

i
c
i
269
Mtodo contbil no caso do contador binrio:
INCR
1
INCR
2
INCR
i
INCR
n1
INCR
n
c
i
= nmero de bits alterados
c
i
= 2
prova de

c
i

c
i
:
pago $2 por cada chamada de INCR
$1 gasto pelo nico 01
$1 ca sentado no bit 1 para pagar 10 no futuro
em cada instante, h $1 sentado em cada bit 1
crdito armazenado nunca negativo
270
concluso: em cada instante,

c
i

c
i
concluso: c
i
:= 2 est correto
custo real total:

n
i=1
c
i

n
i=1
c
i
= 2n
271
Amortizado no mdio
no confunda custo amortizado com custo mdio
amortizado no envolve probabilidades
272
Exemplo 2: Tabela dinmica
Tamanho da tabela aumenta (dobra) quando necessrio
11111
22222
33333
44444
11111
22222
33333
44444
55555
_
_
tam
num[T] = nmero de itens
tam[T] = tamanho da tabela
valores de tam: 0, 1, 2, 4, 8, 16, . . .
273
comea com num[T] = tam[T] = 0
TABLE-INSERT (T, x)
1 se tam[T] = 0
2 ento aloque tabela[T] com 1 posio
3 tam[T] 1
4 se num[T] = tam[T]
5 ento aloque nova com 2 tam[T] posies
6 insira itens da tabela[T] na nova
7 libere tabela[T]
8 tabela[T] nova
9 tam[T] 2tam[T]
10 insira x na tabela[T]
11 num[T] num[T] +1
custo = nmero de insira
274
Seqncia de n TABLE-INSERTs
qual o custo total da seq de operaes?
custo real da i-sima operao:
c
i
=
1 se h espao
i se tabela cheia (ou seja, se i 1 potncia de 2)
custo total da seq de operaes:

c
i
para simplicar clculo de

c
i
, invente custo amortizado
dena custo amortizado de i-sima op: c
i
:= 3
preciso garantir que

c
i

c
i
275
prova de

c
i

c
i
:
$1 para para inserir novo item
$1 pagto adiantado para realocao do novo item
$1 pagto adiantado para realoc de um dos itens antigos
crdito acumulado nunca negativo
logo,

k
i=1
c
i

k
i=1
c
i
para cada k
concluso: c
i
= 3 um bom custo amortizado
custo real total:

n
i=1
c
i

n
i=1
c
i
= 3n
276
Anlise amortizada: mtodo do potencial
Exemplo: Tabela dinmica com insert e delete
mtodo contbil ca difcil
introduz mtodo da funo potencial
277

AULAS4 Up

Enviado por

Dados do documento

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

AULAS4 Up

Enviado por

Direitos autorais:

Formatos disponíveis

Anlise de Algoritmos

(todos os intervalos posteriores a f

[z] := f[x] +f[y];

:= T x, y +z rvore tima para (C

n o nico nmero natural k tal que T(k 1) < n T(k)

n o menor k tal que lg lg . . . lg

n cresce to devagar que quase O(1)

CONTRAI-PESOS (G, uv, w)

(XY ) = minw(xy) : xy E[G], x X, y Y

11 peso peso +min

13 peso peso +chave[u

Você também pode gostar