Aa Slides

ANLISE
DE ALGORITMOS
Paulo Feolo
Instituto de Matemtica e Estatstica
Universidade de So Paulo
agosto 2009
Introduo
P. Feolo (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 n = 8
20 30 15 10 30 20 30 30
Introduo Um exemplo
Algoritmo
SOMAPOSITIVOS (A, n)
1 s 0
2 para i 1 at n faa
3 se A[i] > 0
4 ento s s + A[i]
5 devolva s
Introduo Um exemplo
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
Invariante: no comeo de cada iterao
s a soma dos positivos de A[1 . . i1]

No m, s a soma dos positivos de A[1 . . n]
Introduo Um exemplo
Quanto tempo consome a execuo do algoritmo?
depende da instncia
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

Introduo Um exemplo
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

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
Introduo Um exemplo
Consumo de tempo de SOMAPOS
T(n) : consumo de tempo no pior caso
recorrncia: T(n) = T(n 1) + const
T(n) = ?
preciso aprender a resolver recorrncias

Introduo Um exemplo
Observaes sobre algoritmos recursivos
Problemas com estrutura recursiva:
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
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
Comparao assinttica
de funes
Comparao assinttica de funes Ordem O
funes de N em R
G(n) 0 para n = 0, 1, 2, 3, . . .
Denio 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 sucientemente 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

Exemplo 1: 100n est em O(n

2
)
Prova: Para todo n 100

100 n n n
= n
2
= 1 n
2
Exemplo 2: 2n
3
+ 100n est em O(n
3
)
Prova: Para todo n 1

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

2n
3
+ 100n 2n
3
+ n n n
= 3 n
3
Exemplo 3: n est em O(2

n
)
Prova: prove por induo em n que

Prova: n 2
n
para todo n 1
Exemplo 4: lg n est em O(n)
Prova: para todo n 1

Prova: xxxxxxxxxxxxxxxx n 2
n
Prova: xxxxxxxxxxxxxxxx lg n n
Comparao assinttica de funes Ordem mega
Ordem mega
F (G) tem sabor de F G
F (G) G O(F)
Denio da ordem (G)
Funo F est em (G) se existe c em N
>
tal que
F(n)
1
c
G(n) para todo n sucientemente grande
Comparao assinttica de funes Ordem mega
Exemplos:
n
2
2n est em (n
2
)
nlg n est em (n)
100 n no est em (n
2
)
Comparao assinttica de funes Ordem Theta
Ordem Teta
tem sabor de F = G
Denio da ordem (G)
Funo F est em (G) se F O(G) e F (G)
Comparao assinttica de funes Ordem Theta
Algumas funes em (n
2
):
11n
2
22n + 33
2n
2
+ 3nlg n 4n + 5
Comparao assinttica de funes
Consumo de tempo de algoritmos
Algoritmo linear:
consome (n) unidades de tempo no pior caso
n multiplicado por 10 tempo multiplicado por 10
algoritmos lineares so considerados muito rpidos

Algoritmo quadrtico:
tempo (n
2
) no pior caso
n multiplicado por 10 tempo multiplicado por 100

Comparao assinttica de funes Consumo de tempo de algoritmos
Algoritmo polinomial:
consome tempo O(n

k
) para algum k
exemplos: O(n), O(nlg n), O(n

2
), O(n
100
)
no-exemplos: (2
n
), (1.1
n
)
Algoritmo exponencial:
consome tempo (a
n
) para algum a > 1
exemplos: (2
n
), (1.1
n
)
n multiplicado por 10 tempo elevado a 10

Soluo de
recorrncias
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 4
F(n) ? 1 3 7 15
queremos frmula para F(n)

Fato
F(n) = 2
n
1 para todo n 1
Prova: F(n) = 2 F(n 1) + 1
= 2
2F(n 2) + 1
+ 1
= 4F(n 2) + 3
.
.
.
= 2
j
F(n j) + 2
j
1
= 2
n1
F(1) + 2
n1
1
= 2
n1
+ 2
n1
1
= 2
n
1
Conseqncia
F(n) est em (2
n
)
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(n/2|) + n para todo n 2
F(n 0 1 2 3 4
F(n) ? 1 4 5 12
queremos frmula para F(n)
trate primeiro das potncias de 2

Fato A (potncias de 2)
F(n) = nlg n + n para n = 1, 2, 4, 8, 16, 32, 64, . . .
Prova, com n = 2
j
F(2
j
) = 2 F(2
j1
) + 2
j
= 2
2F(2
j2
) + 2
j1
+ 2
j
= 2
2
F(2
j2
) + 2
1
2
j1
+ 2
j
= 2
3
F(2
j3
) + 2
2
2
j2
+ 2
1
2
j1
+ 2
j
= 2
j
F(2
0
) + 2
j1
2
1
+ + 2
2
2
j2
+ 2
1
2
j1
+ 2
0
2
j
= 2
j
2
0
+ 2
j1
2
1
+ + 2
2
2
j2
+ 2
1
2
j1
+ 2
0
2
j
= (j + 1)2
j
= j 2
j
+ 2
j
Se n no potncia de 2 . . .
Fato B
F(n) 6 nlg n para todo n 2
Prova:
F(n) = nlg n + n quando n potncia de 2
F crescente
. . .
Fato C
F(n)
1
2
nlg n para todo n 2
Prova:
F(n) = nlg n + n quando n potncia de 2
F crescente
. . .
Conseqncia
F(n) est em (nlg n)
Detalhes no alteram a ordem de F:
se F(n) = F(n/2|) + F(n/2|) + 10n
ento F continua em (nlg n)

Exemplo 3
funo F de N em R
>
F(1) = 1 e
F(n) = 3 F(n/2|) + n para todo n 2
frmula para F(n)?

Fato A (para n = 2
j
)
F(2
j
) = 3 3
j
2 2
j
para todo j 0
Prova, por induo em j
se j = 0 ento F(2
j
) = 1 = 3 3
j
2 2
j
agora tome j 1
hiptese de induo: F(2

j1
) = 3
j
2
j
F(2
j
) = 3 F(2
j1
) + 2
j
F(2
j
) = 3
3
j
2
j
+ 2
j
F(2
j
) = 3 3
j
2 2
j
3 = 2
lg 3
3
j
= (2
lg 3
)
j
= (2
j
)
lg 3
= n
lg 3
1.5 < lg 3 < 1.6
n < n
lg 3
< n
2
Conseqncia
F(n) = 3 n
lg 3
2n para n = 1, 2, 4, 8, 16, 32, 64, . . .
Se n no potncia de 2 . . .
Fato B (n arbitrrio)
F(n) 9 n
lg 3
para todo n 1
Fato C (n arbitrrio)
F(n)
1
3
n
lg 3
para todo n 1
Conseqncia
F est em (n
lg 3
)
Detalhes no alteram a ordem de F:
se F(n) = 2 F(n/2|) + F(n/2|) + 10n
ento F continua em (n
lg 3
)
Recorrncias Teorema mestre
Teorema mestre
Se
F : N R
>
F(n) = a F
n
2
+ cn
k
para n = 2
1
, 2
2
, 2
3
, . . .
F crescente
ento
se lg a > k ento F est em (n

lg a
)
se lg a = k ento F est em (n
k
lg n)
se lg a < k ento F est em (n

k
)
Ordenao de vetor
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]

Ordenao de vetor Mergesort
Algoritmo Mergesort
MERGESORT (A, p, r)
1 se p < r
2 ento q (p + r)/2|
3 MERGESORT (A, p, q)
4 MERGESORT (A, q + 1, r)
5 INTERCALA (A, p, q, r)
p q q+1 r
111 333 555 555 777 888 222 444 777 999 999
INTERCALA rearranja A[p . . r] em ordem crescente
supondo A[p . . q] e A[q+1 . . r] crescentes
Tamanho de uma instncia: n = r p + 1
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

Consumo de tempo
recorrncia: T(n) = T(n/2|) + T(n/2|) + n
parcela n representa o consumo de INTERCALA
semelhante a T(n) = 2 T(n/2|) + n
soluo da recorrncia: T est em (nlg n)

Ordenao de vetor Diviso e conquista
Mtodo de diviso e conquista:
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!
Multiplicao de inteiros
35871227428009 11234908764388
Multiplicao de inteiros O problema
Problema
Dados nmeros naturais u e v com n dgitos cada
calcular o produto u v
8 7 6 5 4 3 2 1
7 7 7 6 2 2 2 3
cada nmero tratado como um vetor de dgitos
u v ter 2n dgitos
Algoritmo usual de multiplicao
9 9 9 9
7 7 7 7
6 9 9 9 3
6 9 9 9 3
6 9 9 9 3
6 9 9 9 3
7 7 7 6 2 2 2 3
Consumo: (n
2
) unidades de tempo
Preparando algoritmo mais eciente
u 9 9 9 9 8 8 8 8
a b
Truque (supondo n par)
u = a 10
n/2
+ b
v = c 10
n/2
+ d
u v = a c 10
n
+ (a d + b c) 10
n/2
+ b d
4 multiplicaes de tamanho n/2
bom algoritmo para calculadora pequena!

Multiplicao de inteiros Preparando algoritmo mais eciente
99998888 u
77776666 v
99998888 a
8888 b
77776666 c
6666 d
77762223 ac
1357753103333 ad + bc
59247408 bd
7777580112347408 x
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 u/10
k
|
5 b u mod 10
k
6 c v/10
k
|
7 d v mod 10
k
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 10
2k
+ (ad + bc) 10
k
+ bd
13 devolva x
Consumo de tempo (n potncia de 2)
Tamanho de uma instncia: n
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 (n

2
)
Algoritmo MULTIPLICA no mais rpido que algoritmo usual. . .
Multiplicao de inteiros Algoritmo de KaratsubaOfman
Algoritmo mais eciente
Antes: 4 multiplicaes de tamanho n/2:
u v = a c 10
n
+ (a d + b c) 10
n/2
+ b d
Agora: 3 multiplicaes de tamanho n/2:
u v = a c 10
n
+ (y a c b d) 10
n/2
+ b d
y = (a + b) (c + d)
999988888 u
077766666 v
07769223 ac
5925807408 bd
9888733333 a + b
6744333333 c + d
666923594133333 y
73565931033333 y ac bd
077765801856807408 x
Algoritmo de KaratsubaOfman: um rascunho
KARATSUBA (u, v, n)
1 se n 1
2 ento devolva u v
3 seno k n/2|
5 a u/10
k
|
6 b u mod 10
k
7 c v/10
k
|
8 d v mod 10
k
9 ac KARATSUBA (a, c, k)
10 bd KARATSUBA (b, d, k)
11 y KARATSUBA (a + b, c + d, k+1)
12 x ac 10
2k
+ (y ac bd) 10
k
+ bd
13 devolva x
Idia bsica correta, mas tem erros tcnicos
Consumo de tempo
T(n) : consumo de tempo do algoritmo no pior caso
recorrncia: T(n) = 3 T(n/2|) + n

lg 3
)
1.5 < lg 3 < 1.6
n < n
lg 3
< n
2
para n grande, KARATSUBA bem mais rpido que algoritmo usual

Algoritmo de KaratsubaOfman: verso nal, n arbitrrio
KARATSUBA (u, v, n)
1 se n 3
2 ento devolva u v
3 seno k n/2|
4 a u/10
k
|
5 b u mod 10
k
6 c v/10
k
|
7 d v mod 10
k
8 ac KARATSUBA (a, c, k)
9 bd KARATSUBA (b, d, k)
10 y KARATSUBA (a + b, c + d, k+1)
11 x ac 10
2k
+ (y ac bd) 10
k
+ bd
12 devolva x
Consumo de tempo
recorrncia: T(n) = 2 T(n/2|) + T(n/2| + 1) + n

lg 3
)
Observaes nais:
natural escrever o algoritmo em estilo recursivo
fcil ver que algoritmo est correto
estimar consumo de tempo: difcil
importante saber resolver recorrncias

Segmento de soma mxima
Segmento de soma mxima O problema
Denies:
segmento de um vetor: ndices consecutivos
soma de um segmento
solidez de vetor: soma de um segmento no-vazio de soma mxima

p r
20 30 15 10 30 20 30 30
solidez 35
Problema
Calcular a solidez de um vetor A[p . . r] de nmeros inteiros.
Algoritmo trivial
Idia:
aplicao cega da denio
examina todos os segmentos de A[p . . r]

Segmento de soma mxima Algoritmo 1
Algoritmo 1: trivial
SOLIDEZI (A, p, r)
1 x A[r]
2 para q r 1 decrescendo at p faa
3 s 0
4 para j q at r faa
5 s s + A[j]
6 se s > x ento x s
7 devolva x
p q q+1 r x
20 30 15 10 30 20 30 30 30
incio de uma iterao (linha 2)
Algoritmo 1 est correto
Invariante: no incio de cada iterao
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
para cada q xo, o bloco de linhas 56 repetido r q + 1 vezes
nmero total de repeties do bloco 56:
r1
q=p
(r q + 1) =

n
j=2
j =
1
2
(n
2
+ n 2)
consumo de tempo do algoritmo: (n

2
)
Algoritmo 2: diviso e conquista
Idia:
semelhante a MERGESORT
mas a fase de conquista mais complexa

p q q+1 r
20 30 15 10 30 20 30 30
Algoritmo 2: diviso e conquista
SOLIDEZII (A, p, r)
1 se p = r
2 ento devolva A[p]
3 seno q (p + r)/2|
4 x
SOLIDEZII (A, p, q)
5 x
SOLIDEZII (A, q + 1, r)
6 calcula mximo y
+y
de +A[q]+A[q+1]+
14 x max (x
, y
+ y
, x
)
15 devolva x
p q q+1 r
20 30 15 10 30 20 30 30
calcula mximo y
+y
de +A[q]+A[q+1]+ :
6 y
s A[q]
7 para i q 1 decrescendo at p faa
8 s A[i] + s
9 se s > y
ento y
s
10 y
s A[q + 1]
11 para j q + 2 at r faa
12 s s + A[j]
13 se s > y
ento y
s
Tamanho de uma instncia: n = r p + 1
se n = 1 ento A[p] soluo
agora suponha n 2
hiptese de induo: x
solidez de A[p . . q]
etc.
Consumo de tempo
recorrncia: T(n) = T(n/2|) + T(n/2|) + n
soluo: T est em (nlg n)

Concluso: algoritmo 2 mais rpido que algoritmo 1
Algoritmo 3: programao dinmica
rmeza de A[p . . r]: a maior soma da forma A[i] + + A[r]
a solidez de A[p . . r] o mximo das rmezas

de todos os segmentos iniciais
p r
20 30 15 10 30 20 30 30
rmeza = 30
Problema auxiliar
Calcular a rmeza de todos os segmentos iniciais de A[p . . r]
F[q] a rmeza do segmento inicial A[p . . q]

p r
A 20 30 15 10 30 20 30 30
F 20 10 15 5 35 15 15 30
Propriedade recursiva:
a rmeza de A[p . . q] contm a rmeza de A[p . . q1]
F[q] = max
F[q1] + A[q] , A[q]

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
Invariante: a cada passagem pela linha 2
F[q1] a rmeza de A[p . . q1]
F[q2] a rmeza de A[p . . q2]
etc.
Bloco 68 escolhe a maior das rmezas
Consumo de tempo
T est em (n)
Concluso: algoritmo 3 mais rpido que algoritmo 2
Observaes:
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

Mochila de valor mximo
Motivao:
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:
p
i
= v
i
: problema dos cheques
v
i
= 1 : problema do pen drive
Mochila de valor mximo O problema
Denies:
objetos 1, . . . , n
nmeros naturais p
1
, . . . , p
n
e v
1
, . . . , v
n
p
i
o peso de i
v
i
o valor de i
o peso de um conjunto S de objetos

iS
p
i
o valor de S

iS
v
i
um conjunto S vivel se

iS
p
i
M
Mochila de valor mximo O problema
Problema da mochila
Dados nmeros naturais p
1
, . . . , p
n
, M, v
1
, . . . , v
n
encontrar um subconjunto vivel de 1, . . . , n que tenham valor mximo
algoritmo trivial: tentar todos os subconjuntos 1, . . . , n
consome tempo (2
n
)
inaceitvel. . .
A estrutura recursiva do problema
Estrutura recursiva:
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 p
n
, v)
Recorrncia:
notao: X(n, M) valor de um soluo
X(n, M) = max

X(n1, M) , X(n1, Mp
n
) + v
n
se p
n
> M ento X(n, M) = X(n1, M)
Algoritmo recursivo
Recorrncia transformada em algoritmo:
inaceitvel: consumo de tempo (2

n
)
por que?
refaz muitas vezes a soluo das mesmas subinstncias

Algoritmo de programao dinmica
A recorrncia abre as portas para a programao dinmica:
M e p
i
so nmeros naturais
X tabela indexada por 0 . . n 0 . . M
tabela deve ser preenchida na ordem certa

Mochila de valor mximo Programao dinmica
p
4
2
1
3
v
500
400
300
450
0 1 2 3 4 5
0 0 0 0 0 0 0
1 .0 0 0 0 500 500
2 0 0 400 400 500 500
3 0 300 400 700 700 800
4 0 300 400 700 750 ?
Mochila com n = 4 e M = 5
p
4
2
1
3
v
500
400
300
450
0 1 2 3 4 5
0 0 0 0 0 0 0
1 .0 0 0 0 500 500
2 0 0 400 400 500 500
3 0 300 400 700 700 800
4 0 300 400 700 750 850
Mochila com n = 4 e M = 5
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[m1, L]
5 se L p
m
0
6 ento b X[m1, L p
m
] + v
m
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)
as L primeiras colunas da tabela esto corretas

Consumo de tempo
tempo para preencher uma casa da tabela: no depende de n nem M
tempo total: proporcional ao nmero de casas da tabela
tempo total: (nM)
algoritmo lento. . .
muito sensvel s variaes de M
implicitamente adotamos (n, M) como tamanho de uma instncia
mais razovel dizer que tamnaho (n, lg M|)

Consumo de tempo: apresentao melhorada
Tamanho de uma instncia: (n, lg M|)
consumo de tempo: (n2

lg M
)
algoritmo no polinomial
Comentrios:
denio ideal de tamanho da instncia: 2n + 1
eu gostaria de algoritmo O(n

2
) ou at O(n
100
)
mas isso pedir demais. . .

Mochila de valor
quase mximo
Mochila quase tima O problema
Problema da mochila (de novo)
Dados naturais p
1
, . . . , p
n
, M, v
1
, . . . , v
n
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

Mochila quase tima Algoritmo de aproximao
Idia:
suponha 1 p
i
M
suponha
v
1
p
1
v
2
p
2

v
n
p
n
escolha o maior segmento inicial vivel X de 1, . . . , n
X a resposta a menos que algum v

i
seja melhor
Algoritmo: 50% do mximo
MOCHILAAPROX (n, p, M, v)
1 s x 0
2 m 1
3 enquanto m n e s + p
m
M faa
4 s s + p
m
5 x x + v
m
6 m m + 1
7 se m > n
8 ento devolva x
9 seno devolva max (x, v
m
)
seja X = 1, . . . , m1
seja v(S) :=

iS
v
i
para qualquer S
max (v(X), v
m
)
v(X) + v
m
2
=
1
2
v(X m)
X m mais valioso que qualquer conjunto vivel (veja abaixo)

Fato
v(X m) > v(S) para qualquer conjunto vivel S
Prova:
seja Y = X m
v(Y ) v(S) = v(Y S) v(S Y )

v(Y ) v(S) =

iY S
v
i

iSY
v
i
v(Y ) v(S) =

iY S
v
i
p
i
p
i

iSY
v
i
p
i
p
i
v(Y ) v(S)
v
m
p
m
p(Y S)
v
m
p
m
p(S Y )
v(Y ) v(S) =
v
m
p
m
p(Y ) p(S)
v(Y ) v(S) >

v
m
p
m
M M
v(Y ) v(S) = 0
Consumo de tempo
Tamanho de uma instncia: n
o algoritmo consome (n) unidades de tempo
pr-processamento consome (nlg n)
consumo total: (nlg n)

Observaes nais:
algoritmo de aproximao: idia esperta mas natural
anlise da correo do algoritmo: no obvia
estimativa do consumo de tempo: fcil

A cobertura de um grafo
A cobertura de um grafo
Motivao:
dada rede de corredores de uma galeria de arte
problema: encontrar o menor conjunto de sentinelas

capaz de vigiar a rede
A cobertura de um grafo O problema
Grafos:
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[

r r r
r r r r
r r
r
r r
A cobertura de um grafo O problema
Denies:
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 c

i
ento o custo de uma cobertura X c(X) =

iX
c
i
r r 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
A cobertura de um grafo Algoritmo de aproximao
Complexidade de problema
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

Algoritmo: dobro da cobertura mnima
COBERTURABARATA (V, A, c)
1 para cada i em V faa
2 x
i
0
3 para cada ij em A faa
4 y
ij
0
5 para cada pq em A faa
6 e min(c
p
x
p
, c
q
x
q
)
7 y
pq
y
pq
+ e
8 x
p
x
p
+ e
9 x
q
x
q
+ e
10 X
11 para cada i em V faa
12 se x
i
= c
i
ento X X i
13 devolva X
Invariantes
No incio de cada iterao do bloco de linhas 6-9
i. x
i
=

j
y
ij
para todo i em V
ii. x
i
c
i
para todo i em V
iii. para toda aresta ij j examinada tem-se x
i
= c
i
ou x
j
= c
j
X uma cobertura e
c(X) 2
ijA
y
ij
2 c(Z)
para qualquer cobertura Z
Prova do segundo :
ijA
y
ij

iZ
j
y
ij
(i Z ou j Z)
=

iZ
x
i
(invariante i)

iZ
c
i
(invariante ii)
Prova do primeiro :
iX
c
i
=

iX
x
i
(c
i
= x
i
)
=

iX
j
y
ij
(invariante i)
2

ijA
y
ij
(aresta s tem 2 pontas)
Consumo de tempo
Tamanho de instncia: (n, m)
consumo total: (n + m)
Fim
Obrigado pela ateno!

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

testes s podem mostrar que o algoritmo est errado

anlise pode provar que o algoritmo est correto

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

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

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

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

preciso aprender a resolver recorrncias

cada instncia do problema

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

Exemplo 1: 100n est em O(n

Prova: Para todo n 100

Prova: Para todo n 1

Outra prova: Para todo n 100

Exemplo 3: n est em O(2

Prova: prove por induo em n que

Exemplo 4: lg n est em O(n)

Prova: para todo n 1

F (G) tem sabor de F G

nlg n est em (n)

consome (n) unidades de tempo no pior caso

n multiplicado por 10 tempo multiplicado por 10

algoritmos lineares so considerados muito rpidos

n multiplicado por 10 tempo multiplicado por 100

consome tempo O(n

exemplos: O(n), O(nlg n), O(n

n multiplicado por 10 tempo elevado a 10

sabe-se que F(1) = 1 e

queremos frmula para F(n)

sabe-se que F(1) = 1 e

queremos frmula para F(n)

trate primeiro das potncias de 2

F(n) = nlg n + n quando n potncia de 2

F(n) = nlg n + n quando n potncia de 2

se F(n) = F(n/2|) + F(n/2|) + 10n

ento F continua em (nlg n)

frmula para F(n)?

hiptese de induo: F(2

1.5 < lg 3 < 1.6

se F(n) = 2 F(n/2|) + F(n/2|) + 10n

se lg a > k ento F est em (n

se lg a < k ento F est em (n

vetor crescente se A[p] A[p + 1] A[r]

se n 1 ento A[p . . r] j crescente

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

recorrncia: T(n) = T(n/2|) + T(n/2|) + n

parcela n representa o consumo de INTERCALA

semelhante a T(n) = 2 T(n/2|) + n