Aa Slides

ANLISE
DE ALGORITMOS
Paulo Feofiloff
Instituto de Matemtica e Estatstica
Universidade de So Paulo
agosto 2009
Introduo
P. Feofiloff (IME-USP)
Anlise de Algoritmos
agosto 2009
2 / 102
Introduo
Um exemplo
Problema
Encontrar a soma dos elementos positivos de um vetor A[1 . . n]
Uma instncia do problema: Encontrar a soma dos elementos positivos
do vetor (20, 30, 15, 10, 30, 20, 30, 30)
1
20
30
15
10
30
20 30
n=8
30
agosto 2009
3 / 102
Introduo
Um exemplo
Algoritmo
SOMAPOSITIVOS (A, n)
1 s0
2 para i 1 at n faa
3
se A[i] > 0
4
ento s s + A[i]
5 devolva s
agosto 2009
4 / 102
Introduo
Um exemplo
O algoritmo est correto?

I
testes s podem mostrar que o algoritmo est errado
anlise pode provar que o algoritmo est correto
O algoritmo est correto

Invariante: no comeo de cada iterao
I
s a soma dos positivos de A[1 . . i1]
No fim, s a soma dos positivos de A[1 . . n]
agosto 2009
5 / 102
Introduo
Um exemplo
Quanto tempo consome a execuo do algoritmo?

I
depende da instncia
Consumo de tempo do algoritmo

I
proporcional ao nmero de iteraes
tempo de cada iterao no depende de n
tempo total: proporcional a n
se n dobra, o tempo dobra
se n decuplica, o tempo decuplica
agosto 2009
6 / 102
Introduo
Um exemplo
Observaes sobre consumo de tempo:

I
estimar consumo do algoritmo, independente do computador
despreze constantes multiplicativas: 10 n o mesmo que n
consumo de tempo diferente para cada instncia do problema
agrupe instncias por tamanho
o conceito de tamanho de uma instncia
muitas instncias tm o mesmo tamanho
consumo de tempo no pior caso
consumo de tempo no melhor caso
agosto 2009
7 / 102
Introduo
Um exemplo
De volta ao problema da soma dos elementos positivos
Algoritmo recursivo
SOMAPOS (A, n)
1 se n = 0
2
ento devolva 0
3
seno s SOMAPOS (A, n 1)
4
se A[n] > 0
5
ento devolva s + A[n]
6
seno devolva s
agosto 2009
8 / 102
Introduo
Um exemplo
Consumo de tempo de SOMAPOS

T (n) : consumo de tempo no pior caso
I
recorrncia: T (n) = T (n 1) + const
T (n) = ?
preciso aprender a resolver recorrncias
agosto 2009
9 / 102
Introduo
Um exemplo
Observaes sobre algoritmos recursivos

Problemas com estrutura recursiva:
I
cada instncia do problema

contm uma instncia menor do mesmo problema
Algoritmo recursivo:
se a instncia em questo pequena
resolva-a diretamente
seno
reduza-a a uma instncia menor do mesmo problema
encontre soluo S da instncia menor
use S para construir soluo da instncia original
agosto 2009
10 / 102
Introduo
Um exemplo
Para entender recurso,

preciso primeiro entender recurso.
folclore
Ao tentar resolver o problema,

encontrei obstculos dentro de obstculos.
Por isso, adotei uma soluo recursiva.
um aluno
agosto 2009
11 / 102
Comparao assinttica
de funes
agosto 2009
12 / 102
Comparao assinttica de funes
funes de N em R
G(n) 0 para n = 0, 1, 2, 3, . . .
Ordem O
Definio da ordem O(G)

Funo F est em O(G) se existe c em N> tal que
F (n) c G(n) para todo n suficientemente grande
F est em O(G) tem sabor de F G
. . . tem sabor de F no cresce mais que G
conceito sob medida para tratar de consumo de tempo de algoritmos
agosto 2009
13 / 102
Ordem O
100n est em O(n2 )
Exemplo 1:
Prova: Para todo n 100

100 n n n
= n2
= 1 n2
agosto 2009
14 / 102
Ordem O
2n3 + 100n est em O(n3 )
Exemplo 2:
Prova: Para todo n 1

2n3 + 100n 2n3 + 100n3
102 n3
Outra prova: Para todo n 100

2n3 + 100n 2n3 + n n n
= 3 n3
agosto 2009
15 / 102
Ordem O
n est em O(2n )
Exemplo 3:
Prova: prove por induo em n que

Prova: n 2n para todo n 1
agosto 2009
16 / 102
Exemplo 4:
Prova: para todo n 1
Ordem O
lg n est em O(n)
Prova: xxxxxxxxxxxxxxxx n 2n
Prova: xxxxxxxxxxxxxxxx lg n n
agosto 2009
17 / 102
Ordem mega
Ordem mega
F (G) tem sabor de F G
F (G) G O(F )
Definio da ordem (G)

Funo F est em (G) se existe c em N> tal que
F (n) 1c G(n) para todo n suficientemente grande
agosto 2009
18 / 102
Ordem mega
Exemplos:
I
n2 2n est em (n2 )
n lg n est em (n)
100 n no est em (n2 )
agosto 2009
19 / 102
Ordem Theta
Ordem Teta
tem sabor de F = G
Definio da ordem (G)

Funo F est em (G) se F O(G) e F (G)
agosto 2009
20 / 102
Ordem Theta
Algumas funes em (n2 ):

I
11n2 22n + 33
2n2 + 3n lg n 4n + 5
agosto 2009
21 / 102
Consumo de tempo de algoritmos
Algoritmo linear:
I
consome (n) unidades de tempo no pior caso
n multiplicado por 10 tempo multiplicado por 10
algoritmos lineares so considerados muito rpidos
Algoritmo quadrtico:
I
tempo (n2 ) no pior caso
n multiplicado por 10 tempo multiplicado por 100
agosto 2009
22 / 102
Consumo de tempo de algoritmos
Algoritmo polinomial:
I
consome tempo O(nk ) para algum k
exemplos: O(n), O(n lg n), O(n2 ), O(n100 )
no-exemplos: (2n ), (1.1n )
Algoritmo exponencial:
I
consome tempo (an ) para algum a > 1
exemplos: (2n ), (1.1n )
n multiplicado por 10 tempo elevado a 10
agosto 2009
23 / 102
Soluo de
recorrncias
agosto 2009
24 / 102
Recorrncias
Exemplo 2F(n1)+1
Exemplo 1
funo F de N em R>
sabe-se que F (1) = 1 e

F (n) = 2 F (n 1) + 1 para n 2
F (n 0 1 2 3
F (n) ? 1 3 7
4
15
queremos frmula para F (n)
agosto 2009
25 / 102
Recorrncias
Exemplo 2F(n1)+1
Fato
F (n) = 2n 1 para todo n 1
Prova: F (n) = 2 F (n 1) + 1

= 2 2F (n 2) + 1 + 1
= 4F (n 2) + 3
..
.
= 2j F (n j) + 2j 1
= 2n1 F (1) + 2n1 1
= 2n1 + 2n1 1
= 2n 1
agosto 2009
26 / 102
Recorrncias
Exemplo 2F(n1)+1
Conseqncia
F (n) est em (2n )
agosto 2009
27 / 102
Recorrncias
Exemplo 2F(n/2)+n
Exemplo 2
funo F de N em R>
sabe-se que F (1) = 1 e

F (n) = 2 F (bn/2c) + n para todo n 2
F (n 0 1 2 3
F (n) ? 1 4 5
4
12
queremos frmula para F (n)
trate primeiro das potncias de 2
agosto 2009
28 / 102
Recorrncias
Exemplo 2F(n/2)+n
Fato A (potncias de 2)
F (n) = n lg n + n para n = 1, 2, 4, 8, 16, 32, 64, . . .
Prova, com n = 2j
F (2j ) = 2 F (2j1 ) + 2j

= 2 2F (2j2 ) + 2j1 + 2j
= 22 F (2j2 ) + 21 2j1 + 2j
= 23 F (2j3 ) + 22 2j2 + 21 2j1 + 2j
= 2j F (20 ) + 2j1 21 + + 22 2j2 + 21 2j1 + 20 2j
= 2j 20 + 2j1 21 + + 22 2j2 + 21 2j1 + 20 2j
= (j + 1)2j
= j 2j + 2j
agosto 2009
29 / 102
Recorrncias
Exemplo 2F(n/2)+n
Se n no potncia de 2 . . .
Fato B
F (n) 6 n lg n para todo n 2
Prova:
I
F (n) = n lg n + n quando n potncia de 2
F crescente
...
agosto 2009
30 / 102
Recorrncias
Exemplo 2F(n/2)+n
Fato C
F (n)
1
2
n lg n para todo n 2
Prova:
I
F (n) = n lg n + n quando n potncia de 2
F crescente
...
Conseqncia
F (n) est em (n lg n)
agosto 2009
31 / 102
Recorrncias
Exemplo 2F(n/2)+n
Detalhes no alteram a ordem de F :

I
se F (n) = F (bn/2c) + F (dn/2e) + 10n
ento F continua em (n lg n)
agosto 2009
32 / 102
Recorrncias
Exemplo 3F(n/2)+n
Exemplo 3
funo F de N em R>
F (1) = 1 e
F (n) = 3 F (bn/2c) + n para todo n 2
frmula para F (n)?
agosto 2009
33 / 102
Recorrncias
Exemplo 3F(n/2)+n
Fato A (para n = 2j )
F (2j ) = 3 3j 2 2j
para todo j 0
Prova, por induo em j

I
se j = 0 ento F (2j ) = 1 = 3 3j 2 2j
agora tome j 1
hiptese de induo: F (2j1 ) = 3j 2j
F (2j ) = 3 F (2j1 ) + 2j

F (2j ) = 3 3j 2j + 2j
F (2j ) = 3 3j 2 2j
agosto 2009
34 / 102
Recorrncias
3 = 2lg 3
3j = (2lg 3 )j = (2j )lg 3 = nlg 3
1.5 < lg 3 < 1.6
n n < nlg 3 < n2
Exemplo 3F(n/2)+n
Conseqncia
F (n) = 3 nlg 3 2n para n = 1, 2, 4, 8, 16, 32, 64, . . .
agosto 2009
35 / 102
Recorrncias
Exemplo 3F(n/2)+n
Se n no potncia de 2 . . .
Fato B (n arbitrrio)
F (n) 9 nlg 3 para todo n 1
Fato C (n arbitrrio)
F (n)
1
3
nlg 3 para todo n 1
Conseqncia
F est em (nlg 3 )
agosto 2009
36 / 102
Recorrncias
Exemplo 3F(n/2)+n
Detalhes no alteram a ordem de F :

I
se F (n) = 2 F (bn/2c) + F (dn/2e) + 10n
ento F continua em (nlg 3 )
agosto 2009
37 / 102
Recorrncias
Teorema mestre
Teorema mestre
Se
I
F : N R>
F (n) = a F
F crescente
n
2
+ cnk para n = 21 , 22 , 23 , . . .
ento
I
se lg a > k ento F est em (nlg a )
se lg a = k ento F est em (nk lg n)
se lg a < k ento F est em (nk )
agosto 2009
38 / 102
Ordenao de vetor
agosto 2009
39 / 102
Ordenao de vetor
O problema
Problema da ordenao
Rearranjar um vetor A[p . . r] em ordem crescente
vetor crescente se A[p] A[p + 1] A[r]
agosto 2009
40 / 102
Ordenao de vetor
Mergesort
Algoritmo Mergesort
MERGESORT (A, p, r)
1 se p < r
2
ento q b(p + r)/2c
3
MERGESORT (A, p, q)
4
MERGESORT (A, q + 1, r)
5
INTERCALA (A, p, q, r)
p
111
333
555
555
777
q
q+1
888 222 444
777
999
r
999
INTERCALA rearranja A[p . . r] em ordem crescente

supondo A[p . . q] e A[q+1 . . r] crescentes
agosto 2009
41 / 102
Ordenao de vetor
Mergesort

Tamanho de uma instncia: n = r p + 1
I
se n 1 ento A[p . . r] j crescente
agora suponha n 2
por hiptese de induo, A[p . . q] crescente
por hiptese de induo, A[q+1 . . r] crescente
INTERCALA coloca A[p . . r] em ordem crescente
agosto 2009
42 / 102
Ordenao de vetor
Mergesort
Consumo de tempo
I
recorrncia: T (n) = T (dn/2e) + T (bn/2c) + n
parcela n representa o consumo de INTERCALA
semelhante a T (n) = 2 T (bn/2c) + n
soluo da recorrncia: T est em (n lg n)
agosto 2009
43 / 102
Ordenao de vetor
Diviso e conquista
Mtodo de diviso e conquista:

I
instncia original do problema dividida em duas menores
instncias menores resolvidas recursivamente
as duas solues so combinadas
Segredo do sucesso: diviso e combinao devem ser rpidas!
agosto 2009
44 / 102
Multiplicao de inteiros
35871227428009 11234908764388
agosto 2009
45 / 102
O problema
Problema
Dados nmeros naturais u e v com n dgitos cada
calcular o produto u v
cada nmero tratado como um vetor de dgitos
u v ter 2n dgitos
agosto 2009
46 / 102
Algoritmo usual de multiplicao
6
69
699
777
6
9
9
9
6
9
7
9
9
9
3
2
9
7
9
9
3
99
77
93
3
223
Consumo: (n2 ) unidades de tempo
agosto 2009
47 / 102
Preparando algoritmo mais eficiente
Truque (supondo n par)

I
u = a 10n/2 + b
v = c 10n/2 + d
u v = a c 10n + (a d + b c) 10n/2 + b d
4 multiplicaes de tamanho n/2
bom algoritmo para calculadora pequena!
agosto 2009
48 / 102
99998888
77776666
u
v
99998888
8888
77776666
6666
a
b
c
d
77762223
1357753103333
59247408
ac
ad + bc
bd
7777580112347408
agosto 2009
49 / 102
Algoritmo (supondo que n potncia de 2)

MULTIPLICA (u, v, n)
1 se n = 1
2
ento devolva u v
3
seno k n/2
4
a bu/10k c
5
b u mod 10k
6
c bv/10k c
7
d v mod 10k
8
ac MULTIPLICA (a, c, k)
9
bd MULTIPLICA (b, d, k)
10
ad MULTIPLICA (a, d, k)
11
bc MULTIPLICA (b, c, k)
12
x ac 102k + (ad + bc) 10k + bd
13
devolva x
agosto 2009
50 / 102
Consumo de tempo (n potncia de 2)

Tamanho de uma instncia: n
I
T (n) : consumo de tempo do algoritmo no pior caso
recorrncia: T (n) = 4 T (n/2) + n
n o consumo das linhas 37 e 12
soluo: T (n) est em (n2 )
Algoritmo MULTIPLICA no mais rpido que algoritmo usual. . .
agosto 2009
51 / 102
Algoritmo de KaratsubaOfman
Algoritmo mais eficiente
Antes: 4 multiplicaes de tamanho n/2:

u v = a c 10n + (a d + b c) 10n/2 + b d
Agora: 3 multiplicaes de tamanho n/2:

u v = a c 10n + (y a c b d) 10n/2 + b d
y = (a + b) (c + d)
agosto 2009
52 / 102
999988888
077766666
u
v
5925807408
ac
bd
07769223
9888733333
6744333333
666923594133333
73565931033333
077765801856807408
a+b
c+d
y
y ac bd
x
agosto 2009
53 / 102
Algoritmo de KaratsubaOfman: um rascunho

KARATSUBA (u, v, n)
1 se n 1
2
ento devolva u v
3
seno k dn/2e
5
a bu/10k c
6
b u mod 10k
7
c bv/10k c
8
d v mod 10k
9
ac KARATSUBA (a, c, k)
10
bd KARATSUBA (b, d, k)
11
y KARATSUBA (a + b, c + d, k+1)
12
x ac 102k + (y ac bd ) 10k + bd
13
devolva x
Idia bsica correta, mas tem erros tcnicos
agosto 2009
54 / 102
Consumo de tempo
T (n) : consumo de tempo do algoritmo no pior caso
I
recorrncia:
soluo:
I
I
1.5 < lg 3 < 1.6
n n < nlg 3 < n2
para n grande, KARATSUBA bem mais rpido que algoritmo usual
T (n) = 3 T (bn/2c) + n
T (n) est em (nlg 3 )
agosto 2009
55 / 102
Algoritmo de KaratsubaOfman: verso final, n arbitrrio

KARATSUBA (u, v, n)
1 se n 3
2
ento devolva u v
3
seno k dn/2e
4
a bu/10k c
5
b u mod 10k
6
c bv/10k c
7
d v mod 10k
8
ac KARATSUBA (a, c, k)
9
bd KARATSUBA (b, d, k)
10
y KARATSUBA (a + b, c + d, k+1)
11
x ac 102k + (y ac bd ) 10k + bd
12
devolva x
agosto 2009
56 / 102
Consumo de tempo
I
recorrncia: T (n) = 2 T (dn/2e) + T (dn/2e + 1) + n
soluo: T (n) est em (nlg 3 )
agosto 2009
57 / 102
Observaes finais:
I
natural escrever o algoritmo em estilo recursivo
fcil ver que algoritmo est correto
estimar consumo de tempo: difcil
importante saber resolver recorrncias
agosto 2009
58 / 102
Segmento de soma mxima
agosto 2009
59 / 102
O problema
Definies:
I
segmento de um vetor: ndices consecutivos
soma de um segmento
solidez de vetor: soma de um segmento no-vazio de soma mxima

p
20
30
15
10
30
20 30
r
30
solidez 35
Problema
Calcular a solidez de um vetor A[p . . r] de nmeros inteiros.
agosto 2009
60 / 102
Algoritmo trivial
Idia:
I
aplicao cega da definio
examina todos os segmentos de A[p . . r]
agosto 2009
61 / 102
Algoritmo 1
Algoritmo 1: trivial
SOLIDEZI (A, p, r)
1 x A[r]
2 para q r 1 decrescendo at p faa
3
s0
4
para j q at r faa
5
s s + A[j]
6
se s > x ento x s
7 devolva x
p
20
30
15
q q+1
10 30 20 30
r
30
x
30
incio de uma iterao (linha 2)
agosto 2009
62 / 102
Algoritmo 1
Algoritmo 1 est correto

Invariante: no incio de cada iterao
I
x a solidez do vetor A[q+1 . . r]
ltima iterao: x a solidez de A[p . . r]
Consumo de tempo
Tamanho do vetor: n = r p + 1
I
para cada q fixo, o bloco de linhas 56 repetido r q + 1 vezes
nmero total de repeties do bloco 56:

Pr1
Pn
1
2
q=p (r q + 1) =
j=2 j = 2 (n + n 2)
consumo de tempo do algoritmo: (n2 )
agosto 2009
63 / 102
Algoritmo 2: diviso e conquista
Idia:
I
semelhante a MERGESORT
mas a fase de conquista mais complexa
p
20
30
15
q q+1
10 30 20 30
r
30
agosto 2009
64 / 102
Algoritmo 2
Algoritmo 2: diviso e conquista

SOLIDEZII (A, p, r)
1 se p = r
2
ento devolva A[p]
3
seno q b(p + r)/2c
4
x00 SOLIDEZII (A, p, q)
5
x00 SOLIDEZII (A, q + 1, r)
6
14
15
calcula mximo y 0 +y 00 de +A[q]+A[q+1]+
x max (x0 , y 0 + y 00 , x00 )

devolva x
p
20
30
15
q q+1
10 30 20 30
r
30
agosto 2009
65 / 102
Algoritmo 2
calcula mximo y 0 +y 00 de +A[q]+A[q+1]+ :
6
7
8
9
10
11
12
13
y 0 s A[q]
para i q 1 decrescendo at p faa
s A[i] + s
se s > y 0 ento y 0 s
00
y s A[q + 1]
para j q + 2 at r faa
s s + A[j]
se s > y 00 ento y 00 s
agosto 2009
66 / 102
Algoritmo 2

Tamanho de uma instncia: n = r p + 1
I
se n = 1 ento A[p] soluo
agora suponha n 2
hiptese de induo: x0 solidez de A[p . . q]
etc.
Consumo de tempo
I
recorrncia: T (n) = T (dn/2e) + T (bn/2c) + n
soluo: T est em (n lg n)
Concluso: algoritmo 2 mais rpido que algoritmo 1

agosto 2009
67 / 102
Algoritmo 3: programao dinmica
firmeza de A[p . . r]: a maior soma da forma A[i] + + A[r]
a solidez de A[p . . r] o mximo das firmezas

de todos os segmentos iniciais
p
20
30
15
10
30
20 30
r
30
firmeza = 30
Problema auxiliar
Calcular a firmeza de todos os segmentos iniciais de A[p . . r]
agosto 2009
68 / 102
Algoritmo 3
F [q] a firmeza do segmento inicial A[p . . q]
p
20
30
15
10
30
20
10
15
35
20 30
r
30
15
30
15
Propriedade recursiva:
I
I
a firmeza de A[p . . q] contm a firmeza de A[p . . q1]

F [q] = max F [q1] + A[q] , A[q]
agosto 2009
69 / 102
Algoritmo 3
Algoritmo 3: programao dinmica

SOLIDEZIII (A, p, r)
1 F [p] A[p]
2 para q p + 1 at r faa
3
s F [q1] + A[q]
4
se s > A[q]
5
ento F [q] s
6
seno F [q] A[q]
7 x F [p]
8 para q p + 1 at r faa
9
se F [q] > x ento x F [q]
10 devolva x
agosto 2009
70 / 102
Algoritmo 3

Invariante: a cada passagem pela linha 2
I
F [q1] a firmeza de A[p . . q1]
F [q2] a firmeza de A[p . . q2]
etc.
Bloco 68 escolhe a maior das firmezas
Consumo de tempo
I
T est em (n)
Concluso: algoritmo 3 mais rpido que algoritmo 2
agosto 2009
71 / 102
Algoritmo 3
Observaes:
I
algoritmo SOLIDEZIII um exemplo de programao dinmica
(nada a ver com programao de computadores)
uma tabela armazena solues de subinstncias
o problema precisa ter estrutura recursiva:

soluo de uma instncia contm solues de subinstncias
consumo de tempo: proporcional ao tamanho da tabela
agosto 2009
72 / 102
Mochila de valor mximo
agosto 2009
73 / 102
Motivao:
I
dado um conjunto de objetos e uma mochila
cada objeto tem um peso e um valor
problema: escolher um conjunto de objetos

que tenha o maior valor possvel
mas no ultrapasse a capacidade da mochila
Exemplos:
I
pi = vi : problema dos cheques
vi = 1 : problema do pen drive
agosto 2009
74 / 102
O problema
Definies:
I
objetos 1, . . . , n
nmeros naturais p1 , . . . , pn e v1 , . . . , vn
pi o peso de i
vi o valor de i
P
o peso de um conjunto S de objetos
iS pi
P
o valor de S
iS vi
P
um conjunto S vivel se
iS pi M
I
I
agosto 2009
75 / 102
O problema
Problema da mochila
Dados nmeros naturais p1 , . . . , pn , M , v1 , . . . , vn
encontrar um subconjunto vivel de {1, . . . , n} que tenham valor mximo
algoritmo trivial: tentar todos os subconjuntos {1, . . . , n}
consome tempo (2n )
inaceitvel. . .
agosto 2009
76 / 102
A estrutura recursiva do problema
Estrutura recursiva:
I
seja S soluo da instncia (n, p, M, v)
se n
/ S ento S um soluo da instncia (n 1, p, M, v)
se n S ento S {n} soluo de (n 1, p, M pn , v)
Recorrncia:
I
notao: X(n, M ) valor de um soluo

X(n, M ) = max X(n1, M ) , X(n1, M pn ) + vn
se pn > M ento X(n, M ) = X(n1, M )
agosto 2009
77 / 102
Algoritmo recursivo
Recorrncia transformada em algoritmo:

I
inaceitvel: consumo de tempo (2n )
por que?
refaz muitas vezes a soluo das mesmas subinstncias
agosto 2009
78 / 102
Algoritmo de programao dinmica
A recorrncia abre as portas para a programao dinmica:

I
M e pi so nmeros naturais
X tabela indexada por 0 . . n 0 . . M
tabela deve ser preenchida na ordem certa
agosto 2009
79 / 102
p
4
2
1
3
v
500
400
300
450
0
1
2
3
4
Programao dinmica
0
1
2
3
4
5
0
0
0
0
0
0
.0
0
0
0 500 500
0
0 400 400 500 500
0 300 400 700 700 800
0 300 400 700 750
?
Mochila com n = 4 e M = 5
agosto 2009
80 / 102
p
4
2
1
3
v
500
400
300
450
0
1
2
3
4
Programao dinmica
0
1
2
3
4
5
0
0
0
0
0
0
.0
0
0
0 500 500
0
0 400 400 500 500
0 300 400 700 700 800
0 300 400 700 750 850
Mochila com n = 4 e M = 5
agosto 2009
81 / 102
Programao dinmica
Algoritmo
MOCHILA (n, p, M, v)
1 para L 0 at M faa
2
X[0, L] 0
3
para m 1 at n faa
4
a X[m 1, L]
5
se L pm 0
6
ento b X[m 1, L pm ] + vm
7
se a < b ento a b
8
X[m, L] a
9 devolva X[n, M ]

Invariante: no comeo de cada iterao (linha 1)
I
as L primeiras colunas da tabela esto corretas
agosto 2009
82 / 102
Programao dinmica
Consumo de tempo
I
tempo para preencher uma casa da tabela: no depende de n nem M
tempo total: proporcional ao nmero de casas da tabela
tempo total: (n M )
algoritmo lento. . .
muito sensvel s variaes de M
implicitamente adotamos (n, M ) como tamanho de uma instncia
mais razovel dizer que tamnaho (n, dlg M e)
agosto 2009
83 / 102
Programao dinmica
Consumo de tempo: apresentao melhorada

Tamanho de uma instncia: (n, dlg M e)
I
consumo de tempo: (n 2dlg M e )
algoritmo no polinomial
Comentrios:
I
definio ideal de tamanho da instncia: 2n + 1
eu gostaria de algoritmo O(n2 ) ou at O(n100 )
mas isso pedir demais. . .
agosto 2009
84 / 102
Mochila de valor
quase mximo
agosto 2009
85 / 102
Mochila quase tima
O problema
Problema da mochila (de novo)

Dados naturais p1 , . . . , pn , M , v1 , . . . , vn
encontrar um subconjunto vivel de {1, . . . , n} que tenham valor mximo
no conheo algoritmo rpido
que tal algoritmo que d soluo aproximada?
algoritmo d conjunto vivel de valor > 50% do timo
agosto 2009
86 / 102
Mochila quase tima
Algoritmo de aproximao
Idia:
I
suponha 1 pi M
suponha
escolha o maior segmento inicial vivel X de {1, . . . , n}
X a resposta a menos que algum {vi } seja melhor
v1
v2
vn

p1
p2
pn
agosto 2009
87 / 102
Mochila quase tima
Algoritmo: 50% do mximo

MOCHILAAPROX (n, p, M, v)
1 sx0
2 m1
3 enquanto m n e s + pm M faa
4
s s + pm
5
x x + vm
6
mm+1
7 se m > n
8
ento devolva x
9
seno devolva max (x, vm )
agosto 2009
88 / 102
Mochila quase tima
seja X = {1, . . . , m1}

P
seja v(S) := iS vi para qualquer S
max (v(X), vm )
X {m} mais valioso que qualquer conjunto vivel (veja abaixo)
v(X) + vm
=
2
1
2
v(X {m})
agosto 2009
89 / 102
Mochila quase tima
Fato
v(X {m}) > v(S) para qualquer conjunto vivel S
Prova:
I
seja Y = X {m}
v(Y ) v(S) = v(Y S) v(S Y )

P
P
v(Y ) v(S) =
iY S vi
iSY vi
P
P
vi
v(Y ) v(S) =
iSY
iY S pi pi
v(Y ) v(S)
vm
pm
v(Y ) v(S) =
vm
pm
v(Y ) v(S) >
vm
pm
p(Y S)
p(Y ) p(S)

M M
vm
pm
vi
pi
pi
p(S Y )
v(Y ) v(S) = 0
agosto 2009
90 / 102
Mochila quase tima
Consumo de tempo
Tamanho de uma instncia: n
I
o algoritmo consome (n) unidades de tempo
pr-processamento consome (n lg n)
consumo total: (n lg n)
agosto 2009
91 / 102
Mochila quase tima
Observaes finais:
I
algoritmo de aproximao: idia esperta mas natural
anlise da correo do algoritmo: no obvia
estimativa do consumo de tempo: fcil
agosto 2009
92 / 102
A cobertura de um grafo
agosto 2009
93 / 102
Motivao:
I
dada rede de corredores de uma galeria de arte
problema: encontrar o menor conjunto de sentinelas

capaz de vigiar a rede
agosto 2009
94 / 102
O problema
Grafos:
I
um grafo um par (V, A) de conjuntos
V um conjunto de vrtices
A um conjunto de arestas
cada aresta um par no-ordenado ij de vrtices
i e j so as pontas da aresta ij
o tamanho de um grafo o par (n, m) sendo n = |V | e m = |A|
agosto 2009
95 / 102
O problema
Definies:
I
uma cobertura de um grafo um conjunto X de vrtices

que contm pelo menos uma das pontas de cada aresta
se cada vrtice i tem um custo ci

P
ento o custo de uma cobertura X c(X) = iX ci
r
r
r
r
r
r
r
r
r
Problema da cobertura mnima

Encontrar uma cobertura de custo mnimo em um grafo
cujos vrtices tm custos em N
agosto 2009
96 / 102
Complexidade de problema
I
tudo indica que no existe algoritmo polinomial
mas existe um algoritmo polinomial para cobertura quase mnima
cobertura X cujo custo o dobro do timo
ningum descobriu ainda algoritmo polinomial com fator 1.9
agosto 2009
97 / 102
Algoritmo: dobro da cobertura mnima

COBERTURABARATA (V, A, c)
1 para cada i em V faa
2
xi 0
3 para cada ij em A faa
4
yij 0
5 para cada pq em A faa
6
e min (cp xp , cq xq )
7
ypq ypq + e
8
xp xp + e
9
xq xq + e
10 X
11 para cada i em V faa
12
se xi = ci ento X X {i}
13 devolva X
agosto 2009
98 / 102
Invariantes
No incio de cada iterao do bloco de linhas 6-9
P
i. xi = j yij para todo i em V
ii. xi ci para todo i em V
iii. para toda aresta ij j examinada tem-se xi = ci ou xj = cj

X uma cobertura e
c(X) 2
ijA yij
2 c(Z)
para qualquer cobertura Z
agosto 2009
99 / 102
Prova do segundo :
P
P
P
ijA yij
iZ
j yij
P
=
iZ xi
P
iZ ci
Prova do primeiro :
P
P
iX ci =
iX xi
P
P
=
iX
j yij
P
2 ijA yij
(i Z ou j Z)
(invariante i)
(invariante ii)
(ci = xi )
(invariante i)
(aresta s tem 2 pontas)
agosto 2009
100 / 102
Consumo de tempo
Tamanho de instncia: (n, m)
I
consumo total: (n + m)
agosto 2009
101 / 102
Fim
Obrigado pela ateno!
agosto 2009
102 / 102

Aa Slides

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

Aa Slides

Enviado por

Direitos autorais:

Formatos disponíveis

ANLISE

O algoritmo est correto?

testes s podem mostrar que o algoritmo est errado

anlise pode provar que o algoritmo est correto

O algoritmo est correto

s a soma dos positivos de A[1 . . i1]

No fim, s a soma dos positivos de A[1 . . n]

Quanto tempo consome a execuo do algoritmo?

Consumo de tempo do algoritmo

proporcional ao nmero de iteraes

tempo de cada iterao no depende de n

tempo total: proporcional a n

se n dobra, o tempo dobra

se n decuplica, o tempo decuplica

Observaes sobre consumo de tempo:

estimar consumo do algoritmo, independente do computador

despreze constantes multiplicativas: 10 n o mesmo que n

consumo de tempo diferente para cada instncia do problema

agrupe instncias por tamanho

o conceito de tamanho de uma instncia

muitas instncias tm o mesmo tamanho

consumo de tempo no pior caso

consumo de tempo no melhor caso

De volta ao problema da soma dos elementos positivos

Consumo de tempo de SOMAPOS

recorrncia: T (n) = T (n 1) + const

preciso aprender a resolver recorrncias

Observaes sobre algoritmos recursivos

cada instncia do problema

Para entender recurso,

Ao tentar resolver o problema,

Comparao assinttica de funes

Definio da ordem O(G)

F est em O(G) tem sabor de F G

. . . tem sabor de F no cresce mais que G

conceito sob medida para tratar de consumo de tempo de algoritmos

Comparao assinttica de funes

100n est em O(n2 )

Prova: Para todo n 100

Comparao assinttica de funes

2n3 + 100n est em O(n3 )

Prova: Para todo n 1

Outra prova: Para todo n 100

Comparao assinttica de funes

Prova: prove por induo em n que

Comparao assinttica de funes

Prova: para todo n 1

Comparao assinttica de funes

F (G) tem sabor de F G

Definio da ordem (G)

Comparao assinttica de funes

100 n no est em (n2 )

Comparao assinttica de funes

Definio da ordem (G)

Comparao assinttica de funes

Algumas funes em (n2 ):

Comparao assinttica de funes

Consumo de tempo de algoritmos

consome (n) unidades de tempo no pior caso

n multiplicado por 10 tempo multiplicado por 10

algoritmos lineares so considerados muito rpidos

tempo (n2 ) no pior caso

n multiplicado por 10 tempo multiplicado por 100