1

Complexidade e Eficincia de
Algoritmos
Lucilena de Lima
li_luma@yahoo.com.br
Como avaliamos nosso algoritmo?
3 critrios para avaliar algoritmos:

corretude
simplicidade
eficincia
2
Retomemos um dos
exemplo(exerccios)...
Real[1..n] MediaAcumulada(Inteiro V[1..n])
1: for i := 1 to n
2: soma := 0
3: for j := 1 to i
4: soma += V[j]
5: M[i] := soma / i
6: return M

Corretude
Como podemos provar que o algoritmo correto?

Testes servem apenas para provar que um algoritmo tem
erros, nunca para provar que est correto.. (Dijkstra)

Corretude
A idia garantir que:
em qualquer possvel execuo, cada bloco faz
exatamente o que esperamos que faa
Para isso, devemos
identificar o que deve ser feito por cada bloco
identificar o estado antes do bloco executar
avaliar o efeito do bloco sobre o estado
caracterizar o estado aps a execuo do bloco
3
Corretude
A demonstrao da corretude de um algoritmo cuja
estrutura no apresente ciclos(laos) pode ser
efetuada por simples inspeo. Exemplo:
int soma(int a, int b)
{
int soma;
soma = a+b;
return soma;
}
Corretude - Invariante de lao
No caso de algoritmos que incluam ciclos(laos), uma prova
de correo implica uma anlise da evoluo de cada
ciclo, em todas as suas iteraes.

Um invariante de ciclo uma propriedade que se mantm verdadeira
durante toda a execuo do ciclo e que reflete todas as
transformaes do estado do algoritmo que esse ciclo efetua durante
a sua execuo.

Para utilizarmos um invariante numa prova de correo
temos de demonstrar
Inicializao: O invariante verifica-se antes da primeira iterao;
Preservao: Se o invariante vlido antes de uma iterao,
ento o- tambm depois dessa iterao;
Terminao: A execuo do ciclo pra. No fim desta execuo, o
invariante corresponde a uma propriedade do algoritmo.
4
Corretude - Invariante de lao
Real[1..n] MediaAcumulada(Inteiro V[1..n])
1: for i := 1 to n
2: soma := 0
3: for j := 1 to i
4: soma += V[j]
5: M[i] := soma / i
6: return M

Corretude de MediaAcumulada
Vamos assumir que para qualquer i,
as linhas 2-4 calculam a soma de V[1..i]
Logo, temos a seguinte abstrao
Corretude - Invariante de lao
Real[1..n] MediaAcumulada(Inteiro V[1..n])
1: for i := 1 to n
2-4: soma := calcula a soma de V[1..i]
5: M[i] := soma / i
6: return M

Corretude: invariante de lao
Se soma a soma de i valores, ento
M[i], aps executar a linha 5, necessariamente
a mdia desses valores

Logo, temos outra abstrao...
5
Corretude - Invariante de lao
Real[1..n] MediaAcumulada(Inteiro V[1..n])
1: for i := 1 to n
2-5: M[i] := mdia dos valores de V[1..i]
6: return M
Corretude: invariante de lao
Declarao da invariante:
I(i) = M[1..i-1] armazena as mdias
acumuladas de V[1..i-1]
Corretude - Invariante de lao
Real[1..n] MediaAcumulada(Inteiro V[1..n])
1: for i := 1 to n
2-5: M[i] := mdia dos valores de V[1..i]
6: return M
Corretude: invariante de lao
A base:
para i=1, a condio I(1) trivialmente verdade...
M[1..0] e V[1..0] so vazios;
A manuteno (k-sima execuo do lao):
antes do lao devemos assumir que I(k) verdade
ou seja, que M[1..k-1] est ok!
durante o lao, calculamos M[k] corretamente
ao atingirmos o ponto da invariante, M[1..k] estar ok
fazendo I(k+1) ser verdadeira...
6
Corretude - Invariante de lao
Aps a ltima execuo do lao, i = n+1
aps a ltima execuo do lao, i=n+1
logo, pela invariante, temos que I(n+1) verdade:
M[1..n] contm as mdias acumuladas de V[1..n]
Portanto, o algoritmo est correto!
Simplicidade
Agora que sabemos que o algoritmo correto,
Podemos responder se ele simples?
Responda:
voc teria dificuldades em implement-lo?
voc teria dificuldades em encontrar erros em uma
implementao de outra pessoa?
Nosso algoritmo simples!
De fato, o algoritmo bvio... (?!)
7
Eficincia
intuitivo que a eficincia deve admitir uma
escala de valores.
Portanto, no se trata apenas de verificar se
um algoritmo ou no eficiente...
mas, sim, de dizer o quo eficiente ele .
Eficincia
Na prtica, interessa comparar algoritmos que
resolvam o mesmo problema.
Logo, o resultado da anlise deve refletir apenas o que
intrnseco de cada algoritmo...
Deve abstrair tudo o que for da implementao ou do ambiente
usado para execuo.
Como resolver esse problema?
Mtodo experimental
vrias implementaes completas
um grande nmero de execues controladas
medio cautelosa das variveis de interesse
anlise (estatstica) dos resultados
Mtodo analtico
idia: construir um modelo matemtico do algoritmo
comparar algoritmos com base nos modelos
8
Eficincia
Como podemos avaliar a eficincia do
algoritmo?
Serve rodar o programa e ver o tempo de
execuo para diferentes entradas?
Quanto espao de memria ele precisa?


Exerccio: responda s perguntas acima.
E como devemos
fazer anlise de algoritmos?



Isso j assunto das prximas aulas...
9
Outro Exemplo: Invariante de lao
Problema: Construa um programa que
pesquise(encontre) a ltima ocorrncia do valor k
em um vetor.
int procura(int vetor[], int a, int b, int k)
{
int i,f;
f = -1;
for (i=a; i<=b; i++)
if (vetor[i]==k) f = i;
return f;
}


Continuao... Exemplo(2)
Invariante:
No incio de cada iterao, a varivel f ter o valor -1
caso o valor k no ocorra nas posies [a . . . (i 1)]
do vetor. Caso contrrio, f ter o maior valor no
intervalo [a . . . i 1] tal que vetor[f] = k.
Inicializao:
Antes da primeira iterao i = a e f = 1.
O valor k no pode existir nas posies
[a . . . (a 1)] do vetor: o invariante verifica-se.

10
Continuao... Exemplo(2)
Preservao:
Assume-se que o invariante vlido no incio da iterao i.
Se o valor k no estiver na posio i do array, o valor de f no ser
alterado. No incio da iterao i + 1 a validade do invariante
mantm-se tambm inalterada.
Se o valor k estiver na posio i do vetor, o valor de f ser alterado
para i. No incio da iterao i+1 o invariante verifica-se: f ter o
valor da ltima posio onde k foi encontrado.
Terminao:
No final da execuo do ciclo, i = b + 1.
Se o invariante se mantm vlido ao longo de toda a execuo do
ciclo, ento:
se o valor k existe entre as posies [a..b] do vetor, ento f
ter o valor da ltima posio onde foi encontrado;
caso contrrio, f ter o valor -1.
Uma vez que o valor de f devolvido no final do algoritmo,
podemos dizer que este algoritmo correto.
Exerccio:
Construa os algoritmos solicitados e
apresente sua corretude.
1. Pesquisa da primeira ocorrncia do valor k num
vetor.
2. Pesquisa binria de uma ocorrncia de k num
vetor (lembrando-se que o vetor estar
ordenado).


11
Exerccio:
3. Analise a corretude do algoritmo abaixo e indique se o mesmo
apresenta falhas:
int procura(int vetor[], int a, int b, int k)
{
int i,f ;
i = a; f = -1;
while (i<=b)
{
if ((f==-1) && (vetor[i]==k)) f = i;
i++;
}
return f;
}
Resumindo...

Um algoritmo uma sequncia finita de instrues que
permite computar valores de sada a partir de valores de entrada.
Para descrever algoritmos usamos pseudo-cdigo, uma
forma de linguagem que enfatiza flexibilidade e expresso sem abrir
mo de estrutura e conciso.
Avaliamos algoritmos com base em trs critrios fundamentais:
corretude, simplicidade e eficincia.
Analisar um algoritmo avaliar sua eficincia, ou seja determinar
a quantidade de recursos que requer para operar.