COMPLEXIDADE DE ALGORITMOS

Algoritmos
Seqncia de instrues necessrias para a
resoluo de um problema bem formulado
Permite implementao computacional

COMPLEXIDADE DE ALGORITMOS
Um algoritmo resolve o problema quando para
qualquer entrada produz uma resposta correta
Mesmo resolvendo um problema, um algoritmo
pode no ser aceitvel na prtica por requerer
muito espao e tempo
Um problema considerado INTRATVEL, se
no existe um algoritmo para ele cuja demanda
de recursos computacionais seja razovel.

COMPLEXIDADE DE ALGORITMOS
Questes
O problema em questo tratvel?
Existe um algoritmo que demande
quantidade
razovel
de
recursos
computacionais?
Quais os custos deste algoritmo?
Existe um algoritmo melhor?
Como comparar algoritmos?

COMPLEXIDADE DE ALGORITMOS
Exerccio:

1 ! + 2 ! + 3 ! + ... + n !

COMPLEXIDADE DE ALGORITMOS

Estas e outras questes so abordadas em uma

rea de conhecimento denominada
Anlise de complexidade
de algoritmos

COMPLEXIDADE DE ALGORITMOS
O custo final de um algoritmo pode estar
relacionado a diversos fatores:
- Tempo de execuo
- Utilizao de memria principal
- Utilizao de disco
- Consumo de energia, etc...
Medidas importantes em outros contextos:
- legibilidade do cdigo
- custo de implementao
- portabilidade
- extensibilidade

COMPLEXIDADE DE ALGORITMOS
Exemplo:
Soluo de um sistema de equaes lineares
AX = 0
Mtodos:
Cramer (determinantes)
Gauss (escalonamento)

COMPLEXIDADE DE ALGORITMOS
Estimativa emprica de tempo, para um processador
rodando em 3GHz
n
Cramer
Gauss
2
4 ns
2 ns
3
12 ns
8 ns
4
48 ns
20 ns
5
240ns
40 ns
10
7.3ms
330 ns
20
152 anos
2.7 ms
Em maioria dos casos, complexidade em tempo
preocupao principal

COMPLEXIDADE DE ALGORITMOS
Outro exemplo
- Busca seqencial
- Dado um vetor de nmeros, verificar se um
nmero chave encontra-se neste vetor
char achou = 0;
i = 0;
while (!achou && i<n) {
achou = (vet[i] == chave);
i++;
}
if (achou) return(i);
else return(1);

COMPLEXIDADE DE ALGORITMOS
Outro exemplo
- Busca seqencial
Neste caso no existe um nmero fixo de
operaes!
Isto vai depender de onde o valor chave
encontrado
Por isso, comum realizar a contagem para:
- O melhor caso
- O pior caso
- E o caso mdio

TEMPO DE EXECUO DE ALGORTMOS

Um algoritmo pode rodar mais rpido para
certos conjunto de dados do que para
outros.
Encontrar um caso mdio pode ser muito
difcil, assim os algoritmos so geralmente
medidos pela complexidade de tempo do
pior caso.

TEMPO DE EXECUO DE ALGORTMOS

Alm disso, para certas reas de aplicao (controle de
trfego

area,

cirurgias,

etc.),

conhecimento

da

complexidade do pior caso crucial.

COMPLEXIDADE DE ALGORITMOS
Anlise

de Complexidade de tempo

- Anlise Experimental
- Anlise Terica

COMPLEXIDADE DE ALGORITMOS
Complexidade de tempo:
Pode ser medida empiricamente:
Com funes para o clculo do tempo. Exemplo:
#include <time.h>
time_t t1,t2;
time(&t1);
/*Operaes*/
time(&t2);
double diferenca = difftime(t2,t1);
//diferena em segundos

TEMPO DE EXECUO DE ALGORTMOS

Estudo experimental
- escreva um programa que implemente o
algoritmo;
- execute o programa com conjuntos de dados
de vrios tamanhos e composies;
- use um mtodo para medir o tempo de
execuo com exatido;
- os resultados devem ser parecidos com este

TEMPO DE EXECUO DE ALGORTMOS

Estudos experimentais possuem vrias limitaes:
- preciso implementar e testar o algoritmo para
determinar seu tempo de execuo;
- os experimentos s podem ser feito para um conjunto
limitado de dados de entrada, assim os tempos de
computao resultantes podem no ser indicativos
dos tempos de execuo para entradas no includas
no experimento;
- para comparar dois algoritmos, devem ser utilizados
o mesmo ambiente de hardware e software.

TEMPO DE EXECUO DE ALGORTMOS

iremos agora apresenta um metodologia geral para
analisar o tempo de computao de algoritmos que
- utiliza a descrio de algoritmos em alto-nvel ao
invs de testar uma de suas implementaes
- leva em considerao todas as possveis entradas;
- permite avaliar a eficincia de qualquer algoritmo
de uma maneira que independente dos
ambientes de hardware e software.

COMPLEXIDADE DE ALGORITMOS
Uma boa idia estimar a eficincia de um
algoritmo em funo do tamanho do problema
- Em geral, assume-se que n o tamanho do
problema, ou nmero de elementos que sero
processados
- E calcula-se o nmero de operaes que sero
realizadas sobre os n elementos

ANLISE ASSINTTICA
Deve-se preocupar com a eficincia de algoritmos
quando o tamanho de n for grande
Definio: a eficincia assinttica de um algoritmo
descreve a eficincia relativa dele quando n tornase grande
Portanto, para comparar 2 algoritmos, determinamse as taxas de crescimento de cada um: o algoritmo
com menor taxa de crescimento rodar mais rpido
quando o tamanho do problema for grande

ANLISE ASSINTTICA
Procedimento
1) Escreve o algoritmo em pseudo-cdigo;
2)Conta operaes primitivas (computaes
de baixo nvel que podem ser consideras em
tempo constante de execuo);
3) Anlise a complexidade do algoritmo
usando a notao Big-Oh.

10

Algumas notaes
Notaes que usaremos na anlise de algoritmos
f(n) = O(g(n)) (l-se big-oh, big-o ou da ordem de)
se existirem constantes c e n0 tal que f(n) c*g(n)
quando n n0
- A taxa de crescimento de f(n) menor ou igual taxa de g(n)

f(n) = (g(n)) (l-se mega) se existirem

constantes c e n0 tal que f(n) c*g(n) quando n n0
- A taxa de crescimento de f(n) maior ou igual taxa de g(n)

Algumas notaes
Notaes que usaremos na anlise de algoritmos
f(n) = (g(n)) (l-se theta) se e somente se f(n) =
O(g(n)) e f(n) = (g(n))
- A taxa de crescimento de f(n) igual taxa de g(n)

11

12

Algumas consideraes
Ao dizer que T(n) = O(f(n)), garante-se que T(n) cresce
numa taxa no maior do que f(n), ou seja, f(n) seu limite
superior
Ao dizer que T(n) = (f(n)), tem-se que f(n) o limite
inferior de T(n).
Exemplos
Se f(n)=n2 e g(n)=2n2, ento essas duas funes tm
taxas de crescimento iguais. Portanto, f(n) = O(g(n)) e f(n)
= (g(n))

13

Taxas de crescimento
Algumas regras
Se T1(n) = O(f(n)) e T2(n) = O(g(n)), ento
T1(n) + T2(n) = max(O(f(n)), O(g(n)))
T1(n) * T2(n) = O(f(n) * g(n))
Se T(x) um polinmio de grau n, ento
T(x) = O(xn)

Funes e Taxas de Crescimento

Tempo constante: O(1) (raro)
Tempo sublinear (log(n)): muito rpido (timo)
Tempo linear: (O(n)): muito rpido (timo)
Tempo nlogn: Comum em algoritmos de diviso e conquista.
Tempo polinomial nk : Freqentemente de baixa ordem (k
10), considerado eficiente.
Tempo exponencial: 2n , n!, nn considerados intratveis

14

Funes e Taxas de Crescimento

15

16

Calculando o tempo de execuo

Supondo que as operaes simples demoram uma
unidade de tempo para executar, considere
o programa
n
3
abaixo para calcular o resultado de i
i =1

Incio
declare soma_parcial numrico;
soma_parcial := 0;
para i :=1 at n faa
soma_parcial := soma_parcial+i*i*i;
escreva(soma_parcial);
Fim

17

Calculando o Tempo de Execuo

1 unidade de tempo

Incio
declare soma_parcial numrico;

1 unidade para inicializao

de i,

soma_parcial := 0;

n+1 unidades para testar se

i<=n

para i :=1 at n faa

n unidades para incrementar

i

soma_parcial := soma_parcial+i*i*i;
4 unidades (1 da soma,
2 das multiplicaes e 1
da atribuio)

escreva(soma_parcial);
Fim

1 unidade para escrita

Custo total: 6n + 4 = O(n)

Calculando o Tempo de Execuo

Em geral, como se d a resposta em termos do big-oh,
costuma-se desconsiderar as constantes e elementos
menores dos clculos
No exemplo anterior
- A linha soma_parcial := 0 insignificante em termos
de tempo
- desnecessrio ficar contando 2, 3 ou 4 unidades de
tempo na linha soma_parcial := soma_parcial+i*i*i
- O que realmente d a grandeza de tempo desejada
a repetio na linha para i := 1 at n faa

18

Em geral, no consideramos os termos de ordem inferior

da complexidade de um algoritmo, apenas o termo
predominante.
Exemplo: Um algoritmo tem complexidade T(n) = 3n2 +
100n. Nesta funo, o segundo termo tem um peso
relativamente grande, mas a partir de n0 = 11, o termo
n2 que "d o tom" do crescimento da funo: uma
parbola. A constante 3 tambm tem uma influncia
irrelevante sobre a taxa de crescimento da funo aps
um certo tempo. Por isso dizemos que este algoritmo da
ordem de n2 ou que tem complexidade O(n2).

Regras para o clculo

Repeties
O tempo de execuo de uma repetio o
tempo dos comandos dentro da repetio
(incluindo testes) vezes o nmero de vezes
que executada

19

Regras para o clculo

Repeties aninhadas
- A anlise feita de dentro para fora
- O tempo total de comandos dentro de um grupo
de repeties aninhadas o tempo de execuo
dos comandos multiplicado pelo produto do
tamanho de todas as repeties
- O exemplo abaixo O(n2)
para i := 0 at n faa
para j := 0 at n faa
faa k := k+1;

Regras para o clculo

Comandos consecutivos
- a soma dos tempos de cada um bloco, o que
pode significar o mximo entre eles
- O exemplo abaixo O(n2), apesar da primeira
repetio ser O(n)
para i := 0 at n faa
k := 0;
para i := 0 at n faa
para j := 0 at n faa
faa k := k+1;

20

Regras para o clculo

Se... ento... seno
- Para uma clusula condicional, o tempo de
execuo nunca maior do que o tempo do teste
mais o tempo do maior entre os comandos relativos
ao ento e os comandos relativos ao seno
- O exemplo abaixo O(n)
se i < j
ento i := i+1
seno para k := 1 at n faa
i := i*k;

Exerccio
Estime quantas unidades de tempo so
ecessrias para rodar o algoritmo abaixo
Incio
declare i e j numricos;
declare A vetor numrico de n posies;
i := 1;
enquanto i <= n faa
A[i] := 0;
i := i+1;
para i := 1 at n faa
para j := 1 at n faa
A[i] := A[i]+i+j;
Fim

21

Regras para o clculo

Chamadas a sub-rotinas
Uma sub-rotina deve ser analisada primeiro
e depois ter suas unidades de tempo
incorporadas ao programa/sub-rotina que a
chamou

Regras para o clculo

Sub-rotinas recursivas
- Anlise de recorrncia
- Recorrncia: equao ou desigualdade que descreve
uma funo em termos de seu valor em entradas
menores
- Caso tpico: algoritmos de dividir-e-conquistar, ou
seja, algoritmos que desmembram o problema em
vrios subproblemas que so semelhantes ao problema
original, mas menores em tamanho, resolvem os
subproblemas recursivamente e depois combinam
essas solues com o objetivo de criar uma soluo
para o problema original

22

Regras para o clculo

Exemplo de uso de recorrncia
- Calculo Fatorial n!
sub-rotina fat(n: numrico)
incio
declare aux numrico;
aux := 1
se n = 1
ento aux := 1
seno aux := n*fat(n-1);
fim

Regras para o clculo

sub-rotina fat(n: numrico)
incio
declare aux numrico;
aux := 1
se n = 1
ento aux := 1
seno aux := n*fat(n-1);
fim

T(n) = c+T(n-1)
= 2c+T(n-2)
= ...
= nc +T(1)
= O(n)

23

UMA RPIDA REVISO DE MATEMTICA

Logaritmos e Expoentes
- Propriedades de logaritmos - Propriedades de expoente
log b xy = log b x + log b y
log b x / y = log b x log b y
log b x = log b x

log b a =

log c a
log c b

b log c a = a log c b

a b+ c = a b a c

(a )

b c

= a bc

ab
= a bc
ac
b = a log a b
b c = a c log a b

UMA RPIDA REVISO DE MATEMTICA

Cho (floor)
x= ao maior inteiro menor que x
Teto (ceiling)
x = ao menor inteiro menor que x
Somatria
t

f (i ) = f (s ) + f (s + 1) + f (s + 2) + ... + f (t 1) + f (t )
i=s

24

UMA RPIDA REVISO DE MATEMTICA

Expresses geomtricas f(i) = ai
Dado um nmero inteiro n > 0 e um nmero real 0 < a 1,
1 a n +1
a = a + a + a + ... + a =

1 a
i =0
n

A progresso geomtrica mostra um crescimento exponencial

UMA RPIDA REVISO DE MATEMTICA

Progresses aritmticas
Um exemplo,
n

i = 1 + 2 + 3 + ... + n =
i =1
n

i
i =1

n(n + 1)
2

1
1

= n(n + 1) n +
3
2

25