Anda di halaman 1dari 41

Minicurso em

Eficincia de Algoritmos
Aula 1
Anlise de Complexidade de Algoritmos
verso 3.1
Prof. D.Sc. Fabiano Oliveira
fabiano.oliveira@ime.uerj.br
Anlise de Complexidade
A anlise de complexidade de
algoritmos trata da eficincia dos
algoritmos
Mas como medir eficincia de
algoritmos?
Anlise de Complexidade
Considere a seguinte mtrica de eficincia:
"em qualquer execuo, o algoritmo deve
responder em menos de t unidades de
tempo"
Exemplo: sistemas do Google so
notveis por manterem tempo de
resposta tolervel em qualquer interao
Anlise de Complexidade
Mtrica inadequada, pois tempo de
execuo varia com o hardware!
(Por exemplo, o que seria da anlise de
complexidade se o hardware fosse
infinitamente rpido e sem restries de
quantidade?)
Anlise de Complexidade
Consideremos, portanto, outra mtrica:
"assumindo que cada instruo leva tempo
constante, a eficincia dada pelo nmero
de passos de uma execuo"
Podemos estudar eficincia para
complexidades de pior caso, mdias, de
melhor caso, ou mesmo para instncias de
execuo particulares
Anlise de Complexidade
Um passo de mquina ou mais por passo de algoritmo
Expresso
Contabilizar
(em passos)
x x + 1
1
x x + y (x e y cabem em uma palavra) 1
x x + y (x e y no cabem em uma palavra e soma
tratada via software usando
algoritmo clssico)
mx{ lg (x+1), lg (y+1) }
A(i) 1 1
A(1..N) 1 N
A(i) mx{ A(j) | 1 j N } N
A(i, j) 0, para todo 1 i, j N N
2
m CalcularMedia(A, N) 1 + passos de
CalcularMedia(A, N)
Anlise de Complexidade
Um passo de mquina ou mais por passo de algoritmo:
Expresso
Contabiliza-se
(em passos)
se (x < 10) ento 1
para x = 1 at N faa
N + 1
para cada x X faa |X| + 1
enquanto (x > 0) faa deve ser inferido do
algoritmo
Anlise de Complexidade
Como medir o nmero de passos?
procedimento Ordenar(B(), N: Inteiro)
//Assume: N |B|
//Garante: B(i) B(i+1), para todo 1 i < N
var i, j, t: Inteiro
incio
para i = N at 1 passo -1 faa
para j = 1 at i -1 faa
se B(j) > B(j+1) ento
t B(j)
B(j) B(j+1)
B(j+1) t
fim-se
fim-para
fim-para
fim-procedimento
Como medir o nmero de passos?
procedimento Ordenar(B(), N: Inteiro)
//Assume: N |B|
//Garante: B(i) B(i+1), para todo 1 i < N
var i, j, t: Inteiro
incio
para i = N at 1 passo -1 faa exatamente N+1 execues
para j = 1 at i -1 faa exatamente N(N+1)/2 execues
se B(j) > B(j+1) ento exatamente N(N-1)/2 execues
t B(j) no mximo, N(N-1)/2 execues
B(j) B(j+1) no mximo, N(N-1)/2 execues
B(j+1) t no mximo, N(N-1)/2 execues
fim-se
fim-para
fim-para
fim-procedimento no mximo, (5/2)N
2
-(1/2)N+1 passos
Anlise de Complexidade
Portanto, o algorimo Ordenar executa no
mximo (5/2)N
2
-(1/2)N+1 passos.
Procedendo da mesma maneira com outro
algoritmo, podemos comparar qual tem a
melhor eficincia
Anlise de Complexidade
Considere uma outra implementao de
ordenao e suponha que a complexidade
desta implementao particular seja
10 N log N + 1000 N + 1000000
Qual das duas funes voc escolheria
utilizar?
Anlise de Complexidade
Anlise de Complexidade
N
Tempo
1.a Ordenao
(1000 instrues/ms)
Tempo
2.a Ordenao
(10 instrues/ms)
1 ~ 0,003 ms ~ 2 min
10 ~ 0,2 ms ~ 2 min
100 ~ 25 ms ~ 2 min
1000 ~ 2,5 s ~ 4 min
10000 ~ 4 min ~ 18 min
100000 ~ 7 h ~ 3 h
1000000 ~ 29 dias ~ 2 dias
10000000 ~ 8 anos ~ 12 dias
Note que o grau do polinmio o que
realmente conta a medida que a varivel do
polinmio cresce!
Esta complexidade chamada de
assinttica
Ela um dos critrios mais utilizados para
comparao de eficincia de algoritmos
Anlise de Complexidade
Motivado por isto, existe uma notao
especial que evidencia a essncia da
complexidade, descartando as constantes
multiplicativas e os termos do polinmio de
graus menores -- a notao O (e famlia).
Anlise de Complexidade
Intuio da notao O:
Suponha uma funo T(N) desconhecida. Veja exemplos de afirmaes
sobre o termo de maior crescimento assinttico e suas respectivas
notaes:
Anlise de Complexidade
Termo de maior
crescimento
assinttico
Notao Possveis funes T(N) que
satisfariam a notao
Funes T(N) que NO
satisfariam a notao
Igual a N
2
(N
2
) N
2
+ 10N; 100N
2
10N; N
3
+ 2N
2
; 100; N log N
No mximo N
2
O(N
2
) 100N
2
; 10N; 100; N log N N
3
+ 2N
2
; N
2
lg N
No mnimo N
2
(N
2
) 100N
2
; N
3
+ 2N
2
; N
2
lg N 10N; 100; N log N
Menor que N
2
o(N
2
) 10N; 100; N log N 100N
2
; N
3
+ 2N
2
; N
2
lg N
Maior que N
2
(N
2
) N
3
+ 2N
2
; N
2
lg N 100N
2
; 10N; 100; N log N
Notao O
O(g(n)) = { h(n) | constantes positivas c, n
0
tais que
0 h(n) cg(n), n n
0
}
Pode-se denotar
f(n) O(g(n)) por
f(n) = O(g(n))
Anlise de Complexidade
Notao
(g(n)) = { h(n) | constantes positivas c>0, n
0
tais
que 0 cg(n) h(n), n n
0
}
Pode-se denotar
f(n) (g(n)) por
f(n) = (g(n))
Anlise de Complexidade
Notao
(g(n)) = { h(n) | constantes positivas c
1
> 0, c
2
, n
0

tais que 0 c
1
g(n) h(n) c
2
g(n), n n
0
}
Pode-se denotar
f(n) (g(n)) por
f(n) = (g(n))
Anlise de Complexidade
Notao o
o(g(n)) = { h(n) | constante positiva c > 0,
constante positiva n
0
tais que 0 h(n) < cg(n), n n
0
}
Pode-se denotar f(n) o(g(n)) por f(n) = o(g(n))
Notao
(g(n)) = { h(n) | constante positiva c > 0,
constante positiva n
0
tais que 0 cg(n) < h(n), n n
0
}
Pode-se denotar f(n) (g(n)) por f(n) = (g(n))
Anlise de Complexidade
Revisitando a ordenao:
procedimento Ordenar(B(), N: Inteiro) no mximo, (5/2)N
2
-(1/2)N+1 passos
//Assume: N |B| no mnimo, N
2
+N+1 passos
//Garante: B(i) B(i+1), para todo 1 i < N
var i, j, t: Inteiro
incio
para i = N at 1 passo -1 faa
para j = 1 at i -1 faa
se B(j) > B(j+1) ento
t B(j)
B(j) B(j+1)
B(j+1) t
fim-se
fim-para
fim-para
fim-procedimento
Anlise de Complexidade
Note que, no slide anterior, computamos o menor
nmero de passos e o maior nmero de passos em que
o algoritmo executa para uma entrada de tamanho N
(neste caso, um vetor de N posies, que a varivel
que influencia no nmero de passos deste algoritmo).
Estas complexidades so chamadas respectivamente
de pior caso e melhor caso.
Podemos ainda fazer a anlise de caso mdio, onde
consideramos a mdia do nmero de passos para uma
entrada de tamanho N.
Anlise de Complexidade
Formalmente, seja C um conjunto de variveis que
afetam o nmero de passos de um algoritmo. Seja C
N
o
conjunto de entradas que possuem o mesmo conjunto
N de valores para o conjunto C de variveis. Seja T(E)
o nmero de passos em que o algoritmo executa com
uma entrada E.
Pior caso: mx { T(E) : E C
N
}
Melhor caso: min { T(E) : E C
N
}
Caso mdio: { p(E)T(E) : E C
N
}
onde p(E) a probabilidade de ocorrncia da
entrada E
Anlise de Complexidade
Exemplo: Considere para um algoritmo de ordenao
que C = {N}, onde N o nmero de elementos de um
vetor. Portanto:
Pior caso:
mx { T(E) : E { vetores de tamanho N } }
Melhor caso:
min { T(E) : E { vetores de tamanho N } }
Caso mdio:
{ p(E)T(E) : E { vetores de tamanho N } }
Anlise de Complexidade
Revisitando a ordenao:
procedimento Ordenar(B(), N: Inteiro) (N
2
) passos
//Assume: N |B| no melhor caso e pior caso e
//Garante: B(i) B(i+1), para todo 1 i < N logo, no caso mdio
var i, j, t: Inteiro
incio
para i = N at 1 passo -1 faa
para j = 1 at i -1 faa
se B(j) > B(j+1) ento
t B(j)
B(j) B(j+1)
B(j+1) t
fim-se
fim-para
fim-para
fim-procedimento
Anlise de Complexidade
Contar as instrues pode ser um processo laborioso.
Por outro lado...
o que normalmente importa em relao ao tempo de
execuo de um algoritmo seu crescimento
assinttico (determinado pelo termo de maior grau do
polinmio)
Pergunta: h um processo prtico para se chegar
complexidade sem determinar a funo que fornece o
nmero exato de passos?
Anlise de Complexidade
Processo Prtico
Passo 1: Separe o programa em blocos. Um
bloco um trecho do cdigo que atende a
alguma das definies abaixo:
Um comando
Um comando condicional incluindo os blocos
correspondentes aos trechos ento, seno se, e
seno
Uma repetio, incluindo o bloco de seu corpo
Uma sequncia de blocos
Anlise de Complexidade
procedimento EscreverMochilaMxima(val w(), v(), N, M: Inteiro): Inteiro
var MM(0..N, 0..M): Inteiro, Escolha(1..N, 1..M): Lgico
incio
MM(0, m) 0, m {0,...,M}
para i 1 at N faa
para m 1 at M faa
se w(i) > m ento
MM(i, m), Escolha(i, m) MM(i-1, m), F
seno se MM(i-1, m) > MM(i-1, m-w(i)) + v(i) ento
MM(i, m), Escolha(i, m) MM(i-1, m), F
seno
MM(i, m), Escolha(i, m) MM(i-1, m-w(i)) + v(i), V
fim-se
fim-para
fim-para
m M
para i N at 1 passo -1 faa
se Escolha(i, m) ento
escrever (i)
m m - w(i)
fim-se
fim-para
fim-procedimento
Anlise de Complexidade
Anlise de Complexidade
procedimento EscreverMochilaMxima(val w(), v(), N, M: Inteiro): Inteiro
var MM(0..N, 0..M): Inteiro, Escolha(1..N, 1..M): Lgico
incio
MM(0, m) 0, m {0,...,M}
para i 1 at N faa
para m 1 at M faa
se w(i) > m ento
MM(i, m), Escolha(i, m) MM(i-1, m), F
seno se MM(i-1, m) > MM(i-1, m-w(i)) + v(i) ento
MM(i, m), Escolha(i, m) MM(i-1, m), F
seno
MM(i, m), Escolha(i, m) MM(i-1, m-w(i)) + v(i), V
fim-se
fim-para
fim-para
m M
para i N at 1 passo -1 faa
se Escolha(i, m) ento
escrever (i)
m m - w(i)
fim-se
fim-para
fim-procedimento
Passo 2: Determinao "bottom-up" das
complexidades dos blocos
Seja B um bloco cuja complexidade falta
determinar e tal que todas as complexidades
dos blocos contidos em B j foram
determinadas.
A complexidade de B determinada
conforme a natureza do bloco:
Anlise de Complexidade
Passo 2: (continuao)
Anlise de Complexidade
Natureza do Bloco B Complexidade C(B)
Um comando
complexidade de tempo de
execuo do comando em funo
da entrada; se no depender da
entrada, (1)
Comando condicional com blocos internos B
1
,...,B
k
mx {C(B
1
) , ... , C(B
k
)}
Comando de repetio c com bloco I como corpo
C
1
(I) + ... + C
N
(I)
onde:
N = nmero de iteraes
C
i
(I) = complexidade de execuo do bloco I na
i-sima iterao
Sequncia de blocos B
1
,...,B
k
C(B
1
) + ... + C(B
k
)
Anlise de Complexidade
procedimento EscreverMochilaMxima(val w(), v(), N, M: Inteiro): Inteiro
var MM(0..N, 0..M): Inteiro, Escolha(1..N, 1..M): Lgico
incio
MM(0, m) 0, m {0,...,M}
para i 1 at N faa
para m 1 at M faa
se w(i) > m ento
MM(i, m), Escolha(i, m) MM(i-1, m), F
seno se MM(i-1, m) > MM(i-1, m-w(i)) + v(i) ento
MM(i, m), Escolha(i, m) MM(i-1, m), F
seno
MM(i, m), Escolha(i, m) MM(i-1, m-w(i)) + v(i), V
fim-se
fim-para
fim-para
m M
para i N at 1 passo -1 faa
se Escolha(i, m) ento
escrever (i)
m m - w(i)
fim-se
fim-para
fim-procedimento
Anlise de Complexidade
(1)
(1)
(1)
(1)
(M)
(1)
(M.N)
(M)
(1)
(N)
(1)
(M.N)
procedimento EscreverMochilaMxima(val w(), v(), N, M: Inteiro): Inteiro
var MM(0..N, 0..M): Inteiro, Escolha(1..N, 1..M): Lgico
incio
MM(0, m) 0, m {0,...,M}
para i 1 at N faa
para m 1 at M faa
se w(i) > m ento
MM(i, m), Escolha(i, m) MM(i-1, m), F
seno se MM(i-1, m) > MM(i-1, m-w(i)) + v(i) ento
MM(i, m), Escolha(i, m) MM(i-1, m), F
seno
MM(i, m), Escolha(i, m) MM(i-1, m-w(i)) + v(i), V
fim-se
fim-para
fim-para
m M
para i N at 1 passo -1 faa
se Escolha(i, m) ento
escrever (i)
m m - w(i)
fim-se
fim-para
fim-procedimento
(1)
(1)
(1)
Tudo que foi dito at aqui se referia funo que mede
o nmero de passos em funo de variveis de
entrada. Esta complexidade chamada de
complexidade de tempo
Se, ao invs de nmero de passos, a funo medir a
memria que o algoritmo aloca em nmero de bits em
funo de variveis de entrada, a complexidade
chamada de complexidade de espao
Anlise de Complexidade
Como medimos complexidade de espao?
Anlise de Complexidade
Tipo de Varivel Complexidade de Espao
Escalar Primitiva (Inteiro, Real,
Lgico, DataHora, Caracter, etc.)
(1)
Vetor/Matriz A, cada elemento de
tipo X
(|A|) <Espao de X>
Registro R, com campos de tipos T
1
,
T
2
, , T
K
{ <Espao de T
i
> : i = 1,...,K }
Ponteiro para tipo X (1)
1) Preencha com V ou F:

(ou seja, preencha V na linha 100 coluna O(n)
se 100 = O(n) ou F caso contrrio)
Exerccios
O(n) (n) (n) O(n
2
) (n
2
) (n
2
)
100
3n + 3
10n
2
+ n
2n
3
2) Preencha com V ou F:

Exerccios
o(n) (n) o(n
2
) (n
2
)
100
3n + 3
10n
2
+ n
2n
3
3) Sejam f(n) e g(n) funes assintoticamente
positivas. Prove ou refute:
(a) f(n) = O(g(n)) implica g(n) = O(f(n))
(b) f(n) + g(n) = (min(f(n), g(n)))
(c) f(n) = O(g(n)) implica lg(f(n)) = O(lg(g(n))),
onde lg(g(n)) 1 e f(n) 1 para todo n
suficientemente grande
(d) f(n) = O(g(n)) implica 2
f(n)
= O(2
g(n)
)
(e) f(n) = O((f(n))
2
)
(f) f(n) = O(g(n)) implica g(n) = (f(n))
(g) f(n) = (f(n/2))
(h) f(n) + o(f(n)) = (f(n))
Exerccios
4) Considere o algoritmo de ordenao abaixo:
procedimento Ordenar(B(), N: Inteiro)
var i, j, t: Inteiro
incio
para i = 2 at N faa
t B(i)
j i - 1
enquanto j > 0 e B(j) > t faa
B(j+1) B(j)
j j - 1
fim-enquanto
B(j+1) t
fim-para
fim-procedimento
(a) qual a complexidade de pior caso do algoritmo?
(b) qual a complexidade de melhor caso do algoritmo?
Exerccios
5) Analise a complexidade assinttica do algoritmo abaixo. Note que o
algoritmo comea com a leitura de N e dos vetores s e e e termina ao
escrever o resultado da funo SelecaoMaxima
Exerccios
funo SelecaoMaxima(val i, j, s(), e(): Inteiro): Conjunto
var Selecao: Conjunto // implementao por lista ligada
incio
z i + 1
enquanto z < j faa
enquanto s(z) < e(i) E z < j faa z z + 1 fim-enquanto
se z < j ento
Selecao Selecao { z }
i z
z i + 1
fim-se
fim-enquanto
retornar (Selecao)
fim-funo
ler (N, s(1..N), e(1..N))
e(0), s(N+1) min {s(i) | 1 i N} - 1, e(N) + 1
escrever (SelecaoMaxima(0, N+1, s, e))
6) Analise a complexidade assinttica do algoritmo abaixo. Note que o
algoritmo comea com a leitura de N e dos vetores s e e e termina ao
escrever o resultado da funo SelecaoMaxima2
Exerccios
funo SelecaoMaxima2(val i, j, s(), e(): Inteiro): Conjunto
var Selecao: Conjunto // implementao por lista ligada
incio
para z i + 1 at j faa
se s(z) e(i) ento
Selecao Selecao { z }
i z
fim-se
fim-para
retornar (Selecao)
fim-funo
... // leitura de N, s(1..N), e(1..N)
e(0), s(N+1) min {s(i) | 1 i N} - 1, e(N) + 1
escrever (SelecaoMaxima2(0, N+1, s, e))