Anda di halaman 1dari 31

Medida do Tempo de

Execuo de um
Programa
David Menotti
Algoritmos e Estruturas de Dados I
DECOM UFOP

Classes de
Comportamento
Se f uma funo de complexidade para um algoritmo F,
Assinttico
ento O(f) considerada a complexidade assinttica ou o
comportamento assinttico do algoritmo F.
A relao de dominao assinttica permite comparar funes
de complexidade.
Entretanto, se as funes f e g dominam assintoticamente uma
a outra, ento os algoritmos associados so equivalentes.
Nestes casos, o comportamento assinttico no serve para
comparar os algoritmos.

David Menotti

Algoritmos e Estrutura de
Dados I

Classes de
Comportamento
Por exemplo, considere dois algoritmos F e G aplicados
Assinttico
mesma classe de problemas,
sendo que F leva trs vezes o
tempo de G ao serem executados, isto , f(n) = 3g(n), sendo que
O(f(n)) = O(g(n)).
Logo, o comportamento assinttico no serve para comparar
os algoritmos F e G, porque eles diferem apenas por uma
constante.
Podemos avaliar programas comparando as funes de
complexidade, negligenciando as constantes de
proporcionalidade.
David Menotti

Algoritmos e Estrutura de
Dados I

Comparao de
Programas

Um programa com tempo de execuo O(n) melhor que outro


com tempo O(n2).
Porm, as constantes de proporcionalidade podem alterar esta
considerao.
Exemplo: um programa leva 100n unidades de tempo para ser
executado e outro leva 2n2. Qual dos dois programas melhor?
Depende do tamanho do problema.
Para n < 50, o programa com tempo 2n2 melhor do que o
que possui tempo 100n.
Para problemas com entrada de dados pequena prefervel
usar o programa cujo tempo de execuo O(n2).
Entretanto, quando n cresce, o programa com tempo de
execuo O(n2) leva muito mais tempo que o programa O(n).
David Menotti

Algoritmos e Estrutura de
Dados I

Principais Classes de
Problemas
f(n) = O(1)

Algoritmos de complexidade O(1) so ditos de


complexidade constante.
Uso do algoritmo independe de n.
As instrues do algoritmo so executadas um
nmero fixo de vezes.

David Menotti

Algoritmos e Estrutura de
Dados I

Principais Classes de
Problemas
f(n) = O(log n)

Um algoritmo de complexidade O(log n) dito ter


complexidade logartmica.

Tpico em algoritmos que transformam um problema em


outros menores.

Pode-se considerar o tempo de execuo como menor que


uma constante grande.

Quando n mil, log2n 10, quando n 1 milho, log2n 20.

Para dobrar o valor de log n temos de considerar o


quadrado de n.

A base do logaritmo muda pouco estes valores: quando n


1 milho, o log2n 20 e o log10n 6.

David Menotti

Algoritmos e Estrutura de
Dados I

Principais Classes de
Problemas
f(n) = O(n)

Um algoritmo de complexidade O(n) dito ter


complexidade linear
Em geral, um pequeno trabalho realizado sobre
cada elemento de entrada
a melhor situao possvel para um algoritmo
que tem de processar/produzir n elementos de
entrada/sada.
Cada vez que n dobra de tamanho, o tempo de
execuo dobra.

David Menotti

Algoritmos e Estrutura de
Dados I

Principais Classes de
Problemas
f(n) = O(n log n)

Tpico em algoritmos que quebram um problema


em outros menores, resolvem cada um deles
independentemente e ajuntando as solues
depois.

Quando n 1 milho, nlog2n cerca de 20


milhes.

Quando n 2 milhes, nlog2n cerca de 42


milhes, pouco mais do que o dobro.

David Menotti

Algoritmos e Estrutura de
Dados I

Principais Classes de
Problemas
f(n) = O(n2)

Um algoritmo de complexidade O(n2) dito ter


complexidade quadrtica.
Ocorrem quando os itens de dados so
processados aos pares, muitas vezes em um anel
dentro de outro.
Quando n mil, o nmero de operaes da
ordem de 1 milho.
Sempre que n dobra, o tempo de execuo
multiplicado por 4.
teis para resolver problemas de tamanhos
relativamente pequenos.

David Menotti

Algoritmos e Estrutura de
Dados I

Principais Classes de
Problemas
f(n) = O(n3)

Um algoritmo de complexidade O(n3) dito ter


complexidade cbica.
teis apenas para resolver pequenos problemas.
Quando n 100, o nmero de operaes da
ordem de 1 milho.
Sempre que n dobra, o tempo de execuo fica
multiplicado por 8.

David Menotti

Algoritmos e Estrutura de
Dados I

Principais Classes de
Problemas
f(n) = O(2n)

Um algoritmo de complexidade O(2n) dito ter


complexidade exponencial.
Geralmente no so teis sob o ponto de vista
prtico.
Ocorrem na soluo de problemas quando se usa
fora bruta para resolv-los.
Quando n 20, o tempo de execuo cerca de
1 milho. Quando n dobra, o tempo fica elevado
ao quadrado.

David Menotti

Algoritmos e Estrutura de
Dados I

Principais Classes de
Problemas
f(n) = O(n!)

Um algoritmo de complexidade O(n!) dito ter


complexidade exponencial, apesar de O(n!) ter
comportamento muito pior do que O(2n).
Geralmente ocorrem quando se usa fora bruta
para na soluo do problema.
n = 20 20! = 2432902008176640000, um
nmero com 19 dgitos.
n = 40 um nmero com 48 dgitos.

David Menotti

Algoritmos e Estrutura de
Dados I

Comparao de Funes
de Complexidade

David Menotti

Algoritmos e Estrutura de
Dados I

Comparao de Funes
de Complexidade

(tamanho)

* t = tamanho do problema

David Menotti

Algoritmos e Estrutura de
Dados I

Algoritmo Polinomial

Algoritmo exponencial no tempo de execuo


tem funo de complexidade O(cn); c > 1.
Algoritmo polinomial no tempo de execuo tem
funo de complexidade O(p(n)), onde p(n) um
polinmio.
A distino entre estes dois tipos de algoritmos
torna-se significativa quando o tamanho do
problema a ser resolvido cresce.
Por isso, os algoritmos polinomiais so muito mais
teis na prtica do que os exponenciais.

David Menotti

Algoritmos e Estrutura de
Dados I

Algoritmos Exponenciais x
Polinomiais

Algoritmos exponenciais so geralmente


simples variaes de pesquisa exaustiva.
Algoritmos polinomiais so geralmente
obtidos mediante entendimento mais
profundo da estrutura do problema.
Um problema considerado:

intratvel: se no existe um algoritmo polinomial


para resolv-lo.
bem resolvido: quando existe um algoritmo
polinomial para resolv-lo.

David Menotti

Algoritmos e Estrutura de
Dados I

Algoritmos Exponenciais x
Polinomiais - Excees

A distino entre algoritmos polinomiais eficientes e algoritmos


exponenciais ineficientes possui vrias excees.
Exemplo: um algoritmo com funo de complexidade f(n) = 2 n
mais rpido que um algoritmo g(n) = n5 para valores de n
menores ou iguais a 20.
Tambm existem algoritmos exponenciais que so muito teis na
prtica.
Exemplo: o algoritmo Simplex para programao linear possui
complexidade de tempo exponencial para o pior caso mas
executa muito rpido na prtica.
Tais exemplos no ocorrem com freqncia na prtica, e muitos
algoritmos exponenciais conhecidos no so muito teis.

David Menotti

Algoritmos e Estrutura de
Dados I

Exemplo de Algoritmo
Exponencial
Um caixeiro viajante deseja visitar n cidades de tal forma que

sua viagem inicie e termine em uma mesma cidade, e cada


cidade deve ser visitada uma nica vez
Supondo que sempre h uma estrada entre duas cidades
quaisquer, o problema encontrar a menor rota para a viagem.
A figura ilustra o exemplo para quatro cidades c1, c2, c3, c4, em
que os nmeros nos arcos indicam a distncia entre duas
cidades.

O percurso < c1, c3, c4, c2, c1> uma soluo para o
problema, cujo percurso total tem distncia 24.

David Menotti

Algoritmos e Estrutura de
Dados I

Exemplo de Algoritmo
Exponencial
Um algoritmo simples seria verificar todas as rotas e escolher a

menor delas.
H (n - 1)! rotas possveis e a distncia total percorrida em cada
rota envolve n adies, logo o nmero total de adies n!.
No exemplo anterior teramos 24 adies.
Suponha agora 50 cidades: o nmero de adies seria
50! 1064.
Em um computador que executa 109 adies por segundo, o
tempo total para resolver o problema com 50 cidades seria maior
do que 1045 sculos s para executar as adies.
O problema do caixeiro viajante aparece com freqncia em
problemas relacionados com transporte, mas tambm
aplicaes importantes relacionadas com otimizao de caminho
percorrido.

David Menotti

Algoritmos e Estrutura de
Dados I

Tcnicas de Anlise de
Algoritmos
Determinar o tempo de execuo de um programa
pode ser um problema matemtico complexo;
Determinar a ordem do tempo de execuo, sem
preocupao com o valor da constante envolvida,
pode ser uma tarefa mais simples.
A anlise utiliza tcnicas de matemtica discreta,
envolvendo contagem ou enumerao dos
elementos de um conjunto:

manipulao de somas
produtos,
permutaes,
fatoriais,
coeficientes binomiais,
soluo de equaes de recorrncia

David Menotti

Algoritmos e Estrutura de
Dados I

Anlise do Tempo de
Execuo
Comando de atribuio, de leitura ou de escrita: O(1).
Seqncia de comandos: determinado pelo maior tempo de
execuo de qualquer comando da seqncia.
Comando de deciso: tempo dos comandos dentro do comando
condicional, mais tempo para avaliar a condio, que O(1).
Anel: soma do tempo de execuo do corpo do anel mais o
tempo de avaliar a condio para terminao (geralmente O(1)),
multiplicado pelo nmero de iteraes.
Procedimentos no recursivos: cada um deve ser computado
separadamente um a um, iniciando com os que no chamam
outros procedimentos. Avalia-se ento os que chamam os j
avaliados (utilizando os tempos desses). O processo repetido
at chegar no programa principal.

David Menotti

Algoritmos e Estrutura de
Dados I

Exemplo 1
void exemplo1 (int n)
{
int i, a;
a=0;
for (i=0; i<n; i++)
a+=i;
}

David Menotti

Algoritmos e Estrutura de
Dados I

Exemplo 2
void exemplo2 (int n)
{
int i,j,a;
a=0;
for (i=0; i<n; i++)
for (j=n; j>i; j--)
a+=i+j;
exemplo1(n);
}
David Menotti

Algoritmos e Estrutura de
Dados I

Procedimento No
Algoritmo para ordenar os Recursivo
n elementos de um conjunto A em ordem ascendente.
void Ordena(Vetor A, , int n)
{ /*ordena o vetor A em ordem ascendente*/
int i, j, min,aux;
(1)

for (i = 0; i < n-1; i++)

(2)

{ min = i;

(3)

for (j = i + 1; j < n; j++)

(4)

if ( A[ j ] < A[ min ] ) min = j;

(5)

/*troca A[min] e A[i]*/


aux = A[ min ];

(6)

A[ min ] = A[ i ];

(7)

A[ i ] = aux;

(8)

O que faz a funo?


Como?
Qual a sua
complexidade?

}
}

David Menotti

Algoritmos e Estrutura de
Dados I

Algoritmo de Ordenao

Seleciona o menor elemento do conjunto.


Troca este com o primeiro elemento A[1].
Repita as duas operaes acima com os
n - 1 elementos restantes, depois com os
n - 2, at que reste apenas um.

David Menotti

Algoritmos e Estrutura de
Dados I

Anlise do Procedimento
No Recursivo
Anel Interno
Contm um comando de deciso, com um comando apenas
de atribuio. Ambos levam tempo constante para
serem executados.
Quanto ao corpo do comando de deciso, devemos
considerar o pior caso, assumindo que ser sempre
executado.
O tempo para incrementar o ndice do anel e avaliar sua
condio de terminao O(1).
O tempo combinado para executar uma vez o anel
O(max(1, 1, 1)) = O(1), conforme regra da soma para a
notao O
Como o nmero de iteraes n i 1, o tempo gasto no anel
O((n i 1) x 1) = O(n i 1), conforme regra do produto
para a notao O.
David Menotti

Algoritmos e Estrutura de
Dados I

Anlise do Procedimento
No Recursivo
Anel Externo
Contm, alm do anel interno, quatro comandos de
atribuio.
O(max(1, (n i 1), 1, 1, 1)) = O(n i 1).
A linha (1) executada n - 1 vezes, e o tempo total para
executar o programa est limitado ao produto de uma
constante pelo somatrio de (n i 1): 2
n(n 1) n
n
n2
(
n

1
)

...

O(n 2 )
i 0
2
2 2
Se considerarmos o nmero de comparaes como a
medida de custo relevante, o programa faz (n2)/2 - n/2
comparaes para ordenar n elementos.
Se considerarmos o nmero de trocas, o programa
realiza
Algoritmos e Estrutura de
David
Menotti exatamente n - 1 trocas.

Dados I

Exerccio 1
// Considere A, B e C vetores globais
void p1 (int n)
{
int i, j, k;
for (i=0; i<n; i++)
for (j=0; j<n; j++)
{
C[i][j]=0;
for (k=n-1; k>=0; k--)
C[i][j]=C[i][j]+A[i][k]*B[k][j];
}
}
David Menotti

Algoritmos e Estrutura de
Dados I

Exerccio 2
void p2 (int n)
{
int i, j, x, y;
x = y = 0;
for (i=1; i<=n; i++)
{
for (j=i; j<=n; j++)
x = x + 1;
for (j=1; j<i; j++)
y = y + 1;
}
}

David Menotti

Algoritmos e Estrutura de
Dados I

Exerccio 3
void Exercicio3(n){
int i, j, a;
for (i=0; i<n; i++){
if (x[i] > 10)
for (j=0; j<n; j++)
x[j] = x[j] + 2;
else
x[i] = 1;
j = n-1;
while (j >= 0) {
x[j] = x[j] - 2;
j = j - 1;
}
}
}
David Menotti

Algoritmos e Estrutura de
Dados I

Exerccio 3
void Exercicio3(n){
int i, j, a;
for (i=0; i<n; i++){
if (x[i] > 10)
for (j=i+1; j<n; j++)
x[j] = x[j] + 2;
else
x[i] = 1;
j = n-1;
while (j >= 0) {
x[j] = x[j] - 2;
j = j - 1;
}
}
}
David Menotti

Algoritmos e Estrutura de
Dados I