Introdução À Análise de Algorítmos

Captulo I Introduo Anlise
de Algoritmos
Prof. Eng. D.Sc. Emerson Cordeiro Morais Prof. Eng. D.Sc. Emerson Cordeiro Morais
Prof. Eng. D.Sc. Emerson Cordeiro Morais
2
Sumrio
Algoritmos, Programas e Estruturas de Dados
Complexidades de Pior Caso, Melhor Caso e Caso Mdio
Comportamento Assinttico de Funes
Limite Superior Assinttico e Notao O
Limite Inferior Assinttico e Notao
Limite Superior Justo e Notao
Anlise Assinttica de Algoritmos
Limites Inferiores e Algoritmos timos
Classes de Comportamento Assinttico
Recursividade e Relaes de Recorrncias
3
Algoritmo e Programa
Segundo Dijkstra (1971), um algoritmo corresponde a uma descrio
de um padro de comportamento, expresso em termos de um conjunto
finito de aes.
Estruturas de Dados (ED) e algoritmos esto intimamente ligados.
No se pode estudar estruturas de dados sem considerar os algoritmos
associados a elas, assim a escolha dos algoritmos em geral depende da
representao e da estrutura de dados.
Programar basicamente estruturar dados e construir algoritmos.
De acordo com Wirth (1976), programas so formulaes concretas de
algoritmos abstratos, baseados em representaes e estruturas especficas
de dados.
4
Segundo Dijkstra (1976), uma Linguagem de Programao (LP)
uma tcnica de notao para programar, com a inteno de servir de
veculo, tanto para a expresso do raciocnio algortmico, quanto para a
execuo automtica de um algoritmo por um computador.
Tipos simples ou primitivos de dados so grupos de valores
indivisveis. Um Tipo Abstrato de Dados (TAD) pode ser visto como um
modelo matemtico acompanhado das operaes definidas sobre o
modelo.
A representao do modelo matemtico por trs do TAD realizada
mediante uma Estrutura de Dados (AHO, HOPCROFT & ULLMAN,
1983).
Linguagem de Programao
5
Banco de Dados: armazenamento adequado dos registros de modo a
permitir que diversos tipos de consultas possam ser realizadas de modo
eficiente.
Sistemas Operacionais: gerncia dos blocos livres de memria e de
processos na CPU.
Redes de Computadores: armazenamento eficiente de uma tabela de
IPs.
Otimizao: armazenamento eficiente de matrizes esparsas.
Inteligncia Artificial: resoluo de problemas por meio de buscas
inteligentes.
Interao na Computao
6
O Projeto Genoma Humano tem como objetivo identificar todos os
100.000 genes do DNA humano, determinar as seqncias dos 3 bilhes
de pares de bases qumicas, armazenar estas informaes em banco de
dados e desenvolver ferramentas para anlise de dados. Cada uma dessas
etapas exige algoritmos sofisticados.
A Internet permite que pessoas espalhadas por todo o mundo acessem
e obtenham com rapidez grandes quantidades de informaes. Para isto
so empregados algoritmos inteligentes com a finalidade de gerenciar e
manipular este grande volume de dados.
Aplicaes
7
O Comrcio Eletrnico permite que mercadorias e servios sejam
negociados e trocados eletronicamente A criptografia de chave pblica e
as assinaturas digitais esto entre as tecnologias centrais utilizadas e se
baseiam em algoritmos numricos e na teoria dos nmeros.
Nas Instalaes Comerciais, importante alocar recursos escassos da
maneira mais benfica. Por exemplo, uma empresa de transporte areo
pode designar as tripulaes para os vos da forma menos dispendiosa
possvel, certificando-se que cada vo ser atendido e que as
regulamentaes do governo relativas escala das tripulaes sero
obedecidas.
....
Aplicaes
8
O projeto de algoritmos fortemente influenciado pelo estudo de seus
comportamentos.
Segundo Knuth (1971), existem dois problemas distintos na rea de
anlise de algoritmos:
Anlise de um algoritmo particular: Qual o custo de usar um dado
algoritmo para resolver um problema especfico?
Anlise de uma classe de algoritmos: Qual o algoritmo de menor
custo possvel para resolver um problema particular?
Quando o custo de um algoritmo igual ao menor custo possvel, pode-
se concluir que um algoritmo timo para a medida de custo
considerada.
Anlise de Algoritmo
9
O custo de utilizao de um algoritmo pode ser medido de vrias
maneiras.
Uma delas mediante a execuo do programa em um computador
real.
Desvantagens:
Os resultados so dependentes do compilador, que pode favorecer
algumas construes;
Os resultados dependem do hardware;
Quando grandes quantidades de memria so utilizadas, as medidas
de tempo podem depender desse aspecto.
Anlise de Algoritmo
10
Uma forma mais adequada de se medir o custo de utilizao de um
algoritmo atravs do uso de um modelo matemtico, baseado em um
computador idealizado.
Exemplo: computador MIX (KNUTH, 1968).
O conjunto de operaes a serem executadas deve ser especificado,
assim como o custo associado com a execuo de cada operao.
Mais usual ainda ignorar o custo de algumas das operaes
envolvidas e considerar apenas as operaes mais significantes.
Anlise de Algoritmo
11
Para medir o custo de execuo de um algoritmo defini-se uma funo
de custo ou funo de complexidade f, onde f(n) a medida de tempo
necessrio para executar um algoritmo para um problema de tamanho
n.
Segundo Stanat e McAllister (1977), se f(n) uma medida da
quantidade de tempo necessria para executar um algoritmo de
tamanho n, ento f chamada de funo de complexidade de tempo do
algoritmo.
Se a medida a quantidade de memria associada, ento f chamada
de funo de complexidade de espao do algoritmo.
Anlise de Algoritmo
12
Complexidade de Tempo: anlise do nmero de operaes que um
algoritmo realiza para resolver um determinado problema.
Complexidade de Espao: anlise do espao de memria que um
algoritmo utiliza para resolver um determinado problema.
Complexidade de E/S: anlise da quantidade de acessos a disco que um
algoritmo realiza para resolver um problema.
Complexidade de Comunicao: anlise do nmero de mensagens que
um algoritmo distribudo envia para resolver um problema.
Tipos de Complexidade
13
Considerar-se-, como exemplo, o algoritmo para encontrar o maior
elemento de um vetor v[0 .. n-1], n > 1.
Algoritmo Max
package cap1;
public class Max {
public static int max (int v[], int n){
int max = v[0];
for (int i = 1; i < n; i++){
if (v[i] > max)
max = v[i];
}
return max;
}
}
package cap1;
public class Max {
public static int max (int v[], int n){
int max = v[0];
for (int i = 1; i < n; i++){
if (v[i] > max)
max = v[i];
}
return max;
}
}
14
Seja f uma funo de complexidade tal que f(n) o nmero de
comparaes entre os elementos de v, se v contiver n elementos. Logo:
f(n) = n 1, para n > 0.
Provar-se- que o algoritmo timo.
Teorema: qualquer algoritmo para encontrar o maior elemento de um
conjunto com n elementos, n > 1, faz pelo menos n 1 comparaes.
Prova: Cada um dos n 1 elementos tem que ser mostrado, atravs de
comparaes, que menor do que algum outro elemento. Logo n 1
comparaes so necessrias.
O teorema nos diz que, se o nmero de comparaes for utilizado como
medida de custo, ento o mtodo max timo.
Algoritmo Max
15
Casos de Complexidade
Seja um problema P e seja um algoritmo A que resolve P. Alm disso
seja E = {E
1
, E
2
, ..., E
n
} o conjunto de instncias de P, que tem tamanho
n. Sendo t(E
i
) o nmero de operaes realizadas por A para resolver a
instncia E
i
, ento:
Complexidade de Pior Caso:
MAX {t(E
i
)}, onde: E
i
c E
Complexidade de Melhor Caso:
MIN {t(E
i
)}, onde: E
i
c E
Complexidade de Caso Mdio:
{p(E
i
)t(E
i
)}, onde: E
i
c E
obs: p(E
i
) a probabilidade da instncia E
i
ocorrer.
16
Melhor caso: menor tempo de execuo sobre todas as entradas de
tamanho n.
Pior caso: maior tempo de execuo sobre todas as entradas de
tamanho n, isto , corresponde ao nmero de passos que o algoritmo
efetua para a entrada mais desfavorvel;
A complexidade de pior caso fornece um limite superior para o nmero
de passos que o algoritmo pode efetuar, em qualquer caso;
Em resumo, se f uma funo de complexidade baseada na anlise de
pior caso, o custo de aplicar o algoritmo nunca maior do que f(n).
Melhor e Pior Caso
17
Caso mdio (ou caso esperado): mdia dos tempos de execuo de
todas as entradas de tamanho n.
Na anlise do caso esperado, supe-se uma distribuio de
probabilidades sobre o conjunto de entradas de tamanho n e o custo
mdio obtido com base nessa distribuio.
A anlise do caso mdio geralmente muito mais difcil de obter do
que as anlises do melhor e do pior caso.
comum supor uma distribuio de probabilidades em que todas as
entradas possveis so igualmente provveis.
Na prtica, isso nem sempre verdade.
Caso Mdio
18
Considerar-se- o problema de encontrar o maior e o menor elemento
de um vetor de inteiros v[0 .. n-1], n > 1.
Algoritmo MaxMin1
package cap1;
public class MaxMin1 {
public static int[] maxMin1 (int v[], int n){
int max = v[0], min = v[0];
for (int i = 1; i < n; i++){
if (v[i] > max) max = v[i];
if (v[i] < min) min = v[i];
}
int maxMin[] = new int[2];
maxMin[0] = max;
maxMin[1] = min;
return maxMin;
}
}
package cap1;
for (int i = 1; i < n; i++){
}
maxMin[0] = max;
maxMin[1] = min;
return maxMin;
}
}
19
Seja f uma funo de complexidade tal que f(n) o nmero de
comparaes entre os elementos de v, se v contiver n elementos. Logo,
a expresso para o melhor caso, pior caso e caso mdio :
f (n) = 2(n -1), para n > 0
O algoritmo MaxMin1 pode ser facilmente melhorado. Basta observar
que a comparao v[i] < min somente necessria quando o resultado
da comparao v[i] > max falso.
Algoritmo MaxMin1
20
Algoritmo MaxMin2
package cap1;
for (int i = 1; i < n; i++){
if (v[i] > max) max = v[i]
else if (v[i] < min) min = v[i];
}
maxMin[0] = max;
maxMin[1] = min;
return maxMin;
}
}
package cap1;
for (int i = 1; i < n; i++){
if (v[i] > max) max = v[i]
else if (v[i] < min) min = v[i];
}
maxMin[0] = max;
maxMin[1] = min;
return maxMin;
}
}
21
Para esta implementao os casos a considerar so:
Melhor Caso: f (n) = n - 1
Pior Caso: f (n) = 2(n 1)
Caso Mdio: f (n) = 3n/2 - 3/2
O melhor caso ocorre quando os elementos de v esto em ordem
crescente.
O pior caso ocorre quando os elementos de v esto em ordem
decrescente.
No caso mdio, v[i] maior do que max a metade das vezes. Logo:
Algoritmo MaxMin2
2
3
2
3
2
1
1 ) ( =
+ =
n n
n n f
22
Considere o seguinte algoritmo:
Comparar os elementos de v aos pares, separando-os em dois
subconjuntos de acordo com o resultado da comparao, colocando
os maiores em um subconjunto e os menores no outro, a um custo
de n/2 comparaes;
O mximo obtido do subconjunto que contm os maiores
elementos, a um custo de n/2 1 comparaes;
O mnimo obtido do subconjunto que contm os menores
elementos, a um custo de n/2 1 comparaes.
Algoritmo MaxMin3
. . .
. . .
Contm o mximo
Contm o mnimo
23
Algoritmo MaxMin3
package cap1;
int max, min, FimDoAnel;
if ((n % 2) > 0) {
v[n] = v[n-1];
FimDoAnel = n;
}
else FimDoAnel = n - 1;
if (v[0] > v[1]) {
max = v[0];
min = v[1];
}
else {
max = v[1];
min = v[0];
}
int i = 2;
package cap1;
int max, min, FimDoAnel;
if ((n % 2) > 0) {
v[n] = v[n-1];
FimDoAnel = n;
}
else FimDoAnel = n - 1;
if (v[0] > v[1]) {
max = v[0];
min = v[1];
}
else {
max = v[1];
min = v[0];
}
int i = 2;
while (i < FimDoAnel) {
if (v[i] > v[i+1]) {
if (v[i+1] < min) min = v[i+1];
}
else {
if (v[i+1] > max) max = v[i+1];
}
i = i + 2;
} // Fim do While
maxMin[0] = max;
maxMin[1] = min;
return maxMin;
} // Fim do Mtodo
} // Fim da Classe
while (i < FimDoAnel) {
if (v[i] > v[i+1]) {
if (v[i+1] < min) min = v[i+1];
}
else {
if (v[i+1] > max) max = v[i+1];
}
i = i + 2;
} // Fim do While
maxMin[0] = max;
maxMin[1] = min;
return maxMin;
} // Fim do Mtodo
} // Fim da Classe
24
Os elementos de v so comparados dois a dois: os elementos maiores
so comparados com max; e os elementos menores so comparados
commin.
Quando n mpar, o elemento que est na posio v[n] duplicado na
posio v[n + 1] para evitar um tratamento de exceo.
Logo, a expresso para o melhor caso, pior caso e caso mdio :
Algoritmo MaxMin3
0 , 2
2
3
2
2
2
2
2
) ( > =
+ = n
n n n n
n f
25
A tabela apresenta o nmero de comparaes dos programas MaxMin1,
MaxMin2 e MaxMin3.
Os algoritmos MaxMin2 e MaxMin3 so superiores ao algoritmo
MaxMin1 de forma geral.
O algoritmo MaxMin3 superior ao algoritmo MaxMin2 com relao
ao pior caso e bastante prximo quanto ao caso mdio.
Comparao dos Algoritmos
26
Para responder temos de conhecer o Limite Inferior para essa classe de
algoritmos.
Dado um modelo de computao que expresse o comportamento do
algoritmo, o Orculo informa o resultado de cada passo possvel.
Para alcanar o limite inferior, o orculo procura sempre fazer com que
o algoritmo trabalhe o mximo, escolhendo como resultado da prxima
comparao aquele que cause o maior trabalho possvel necessrio para
determinar a resposta final.
Algoritmo mais eficiente?
27
Teorema: Qualquer algoritmo para encontrar o maior e o menor
elemento de um conjunto com n elementos no ordenados, n > 1, faz
pelo menos 3n/2 2 comparaes (HOROWITZ & SAHNI, 1978).
Prova: A tcnica utilizada define um orculo que descreve o
comportamento do algoritmo por meio de um conjunto de n-tuplas,
mais um conjunto de regras associadas que mostram as tuplas possveis
(estados) que um algoritmo pode assumir a partir de uma dada tupla e
uma nica comparao.
Utilizao do Orculo
28
O comportamento do algoritmo pode ser descrito por uma 4-upla
representada por (a, b, c, d):
a representa o nmero de elementos que nunca foram comparados;
b representa o nmero de elementos que foram vencedores e nunca
perderam em comparaes realizadas;
c representa o nmero de elementos que foram perdedores e nunca
venceram em comparaes realizadas;
d representa o nmero de elementos que foram vencedores e
perdedores em comparaes realizadas.
O algoritmo inicia no estado (n, 0, 0, 0) e termina com (0, 1, 1, n-2).
Utilizao do Orculo
29
Aps cada comparao, a tupla (a, b, c, d) consegue progredir apenas
se ela assume um dentre os seis estados possveis abaixo:
O primeiro passo requer necessariamente a manipulao do
componente a.
O caminho mais rpido para levar a at zero requer n/2 mudanas de
estado e termina com a tupla (0, n/2, n/2, 0) (por meio de comparao
dos elementos de a dois a dois).
Utilizao do Orculo
30
A seguir, para reduzir o componente b at um so necessrias n/2 - 1
mudanas de estado (mnimo de comparaes necessrias para obter o
maior elemento de b). Idem para c, com n/2 - 1 mudanas de estado.
Logo, para obter o estado (0, 1, 1, n-2) a partir do estado (n, 0, 0, 0) so
necessrias n/2 + n/2 - 1 + n/2 - 1 = 3n/2 - 2 comparaes.
Isto , se o nmero de comparaes entre os elementos de um vetor for
utilizado como medida de custo, ento o algoritmo MaxMin3 timo.
Utilizao do Orculo
31
O mtodo pesqSeq1 realiza a busca de um elemento em um vetor v,
comn ns. A varivel x corresponde chave do n procurado.
Ao final, retorna: o ndice do n procurado ou valor negativo (-1),
caso a chave no se encontre na lista.
Pesquisa Sequencial
package cap1;
public class PesqSeq1 {
public static int pesqSeq1 (int v[], int n, int x){
int i = 0, busca = -1;
while (i < n){
if (v[i] == x){
busca = i;
i = n;
}
else i = i + 1;
}
return busca;
}
}
package cap1;
int i = 0, busca = -1;
while (i < n){
if (v[i] == x){
busca = i;
i = n;
}
else i = i + 1;
}
return busca;
}
}
32
O pesqSeq2 realiza a mesma busca, porm com o artifcio da criao
de um novo n, que possui o valor procurado, na posio n + 1.
Dessa forma, o algoritmo sempre encontra um n com o valor
desejado, evitando o teste de fim do vetor.
Pesquisa Sequencial
package cap1;
int busca, i = 0;
v[n] = x;
while (v[i] != x)
i = i + 1;
if (i != n) busca = i; //elemento encontrado
else busca = -1; //elemento no encontrado
return busca;
}
}
package cap1;
int busca, i = 0;
v[n] = x;
while (v[i] != x)
i = i + 1;
if (i != n) busca = i; //elemento encontrado
else busca = -1; //elemento no encontrado
return busca;
}
}
33
Os casos a considerar so:
Melhor Caso: f (n) = 1
Pior Caso:
f (n) = 2n, para o pesqSeq1
f (n) = n, para o pesqSeq2
Caso Mdio: f (n) = (n + 1)/2, se sempre houver sucesso na busca e
cada registro tiver a mesma probabilidade 1/n de ser acessado.
Isto :
Pesquisa Seqencial
n
n
n f + + + + = - 3 2 1
1
) (

2
1
2
1 1 1
) (
1
+
=
'
+
'
+
= =

=
n n n
n
i
n
n f
n
i
34
Seja q a probabilidade de sucesso na busca. Alm disso, suponha que
sejam idnticas as probabilidades da chave procurada se encontrar em
posies distintas da lista. Leva-se em considerao que existe n + 1
entradas distintas, n com sucesso e a possibilidade de insucesso.
Busca sem sucesso:
p(E
0
) = 1 q, probabilidade de insucesso.
t(E
0
) = n
Busca com sucesso:
p(E
i
) = q/n, probabilidade do elemento se encontrar na i-sima
posio.
t(E
i
) = i, para 1 i n.
Complexidade de Caso Mdio
=
=
n
i
i i
t p n f
0
) ( ) ( ) (
35
Casos particulares:
q = 1 f(n) n/2
q = 1/2 f(n) 3n/4
q = 0 f(n) = n
Pesquisa Seqencial
? A q q n n f
n
qn q qn q
qn n n f
n n
n
q
qn n n f
n n
n
q
qn n n f
i
n
q
qn q i
n
q
n q n f
E t E p E t E p n f
E t E p E t E p E t E p n f
n
i
n
i
n
i
n
i
i i
n
i
i i
+ =
+ = + + =
'
+
'
+ + =
'
+
'
+
+ =
+ = + =
+ =
+ = =

= =
=
= =
) 2 (
2
1
) (
2 2 2 2
) (
2 2
) (
2
) 1 (
) (
) 1 ( ) (
) ( ) ( ) ( ) ( ) (
) ( ) ( ) ( ) ( ) ( ) ( ) (
2
1 1
1
0 0 0 0
1
0 0
0
36
No caso de conjuntos ordenados, um algoritmo mais eficiente o de
pesquisa binria.
Pesquisa Binria
package cap1;
public class PesqBin {
public static int pesqBin (int v[], int n, int x){
int busca = -1, meio, inf = 0, sup = n - 1;
while (inf <= sup){
meio = (sup + inf)/2;
if (v[meio] == x){
busca = meio;
inf = sup + 1;
}
else if (v[meio] < x) inf = meio + 1;
else sup = meio 1;
}
return busca;
}
}
package cap1;
public class PesqBin {
public static int pesqBin (int v[], int n, int x){
int busca = -1, meio, inf = 0, sup = n - 1;
while (inf <= sup){
meio = (sup + inf)/2;
if (v[meio] == x){
busca = meio;
inf = sup + 1;
}
else if (v[meio] < x) inf = meio + 1;
else sup = meio 1;
}
return busca;
}
}
37
No melhor caso, encontra-se o elemento com uma comparao.
No pior caso, a cada iterao, ou o algoritmo pra, ou o valor sup inf
dividido por 2.
Antes da 1 interao, sup inf = n / 2
0
Aps a 1 interao, sup inf = n / 2
1
Aps a 2 interao, sup inf = n / 2
2
...
Aps a k interao, sup inf = n / 2
k
Pesquisa Binria
38
No pior caso, sup inf = 1, isto encontrar k tal que:
Pesquisa Binria
17 000 . 100 log :
log ) (
log
log 2 log
log 2 log
2
1
2
2
2
2
2 2
2 2
}
=
=
=
=
=
=
ex
n n f
n k
n k
n
n
n
k
k
k
39
Comportamento Assinttico de Funes
O parmetro n fornece uma medida da dificuldade para se resolver o
problema.
Para valores suficientemente pequenos de n, qualquer algoritmo custa
pouco para ser executado, mesmo os ineficientes.
A escolha do algoritmo no um problema crtico para problemas de
tamanho pequeno.
Logo, a anlise de algoritmos realizada para valores grandes de n, isto
, estuda-se o comportamento assinttico das funes de custo.
40
Dominao Assinttica
Definio: Uma funo g(n) domina assintoticamente outra funo
f(n) se existem duas constantes positivas c e n
0
tais que, para n n
0
, tem-
se: |f(n)| c|g(n)|.
Ex: Sejam g(n) = (n + 1)
2
e f(n) = n
2
As funes g(n) e f(n) dominam assintoticamente uma a outra, uma
vez que: 0 n |, 1) (n | 1 | n | 1 n |, n | 4 | 1) (n |
2 2 2 2
u + u +
41
Notao
Knuth (1968) sugeriu uma notao para dominao assinttica. Para
expressar que g(n) domina assintoticamente f(n), escrevemos f(n) =
(g(n)) (f(n) da ordem no mximo de g(n)).
Definio: Uma funo f(n) O(g(n)) se e somente se existir duas
constantes positivas c e n
0
, tais que:
f(n) e cg(n), para todo n n
0
.
Formalmente:
Isto , g(n) um limite superior assinttico para f(n).
0 0
), ( ) ( 0 | 0
)), ( ( ) (
n n n cg n f n c
n g n f
u > n
0 =
42
Notao
Graficamente:
O valor da constante n
0
mostrado o menor valor possvel, mas
qualquer valor maior tambm vlido.
Exemplo: quando se diz que o tempo de execuo T(n) de um programa
O(n
2
), significa que existem constantes c e n
0
tais que, para valores de n
n
0
, T(n) cn
2
.
43
Exemplos de Notao
Ex1: g(n) = (n + 1)
2
g(n) (n
2
), quando n
0
= 1 e c = 4.
Isto porque (n + 1)
2
4n
2
, para n 1.
Ex2: g(n) = n e f(n) = n
2
Sabe-se que g(n) (n
2
), pois para n 0, n n
2
.
Entretanto f(n) no (n).
Suponha que existam constantes c e n
0
, tais que para todo n n
0
, n
2
cn.
Logo c n para qualquer n n
0
, e no existe uma constante c que
possa ser maior ou igual a n para todo n.
44
Exemplos de Notao
Ex3: g(n) = 3n
3
+ 2n
2
+ n (n
3
)
Basta mostrar que 3n
3
+ 2n
2
+ n 6n
3
, para n 0.
A funo g(n) = (n
4
), entretanto esta afirmao mais fraca do
que dizer g(n) (n
3
).
Ex4: g(n) = log
5
n (log
25
n)
O log
b
n difere do log
c
n por uma constante que no caso log
b
c.
Como n = c
log
c
n
, tomando o logaritmo base b em ambos os lados da
igualdade, tem-se que:
log
b
n = log
b
c
log
c
n
= log
c
n.log
b
c
Exemplo: log
5
n = log
5
25
log
25
n
= log
25
n.log
5
25 = 2.log
5
n
45
Operaes com
Ex: regra da soma: (f(n)) + (g(n))
Suponha trs trechos cujos tempos de execuo so: (n), (n
2
) e
(nlogn).
O tempo de execuo dos dois primeiros trechos O(max(n, n
2
)),
que (n
2
).
O tempo de execuo de todos os trs trechos ento O(max(n
2
,
nlog n)), que (n
2
).
46
Notao
Especifica um limite inferior para a funo, por um fator constante.
Definio: Uma funo f(n) (g(n)) se existirem duas constantes c e
n
0
tais que f(n) cg(n), para todo n n
o
.
Isto , g(n) um limite inferior assinttico para f(n). Assim, esta
notao utilizada para definir tempo computacional de problemas.
Graficamente:
47
Notao
Para todos os valores direita de n
0
, o valor de f(n) est sobre ou acima do
valor de cg(n).
Formalmente:
Ex1: Para mostrar que g(n) = 3n
3
+ 2n
2
(n
3
).
Basta fazer c = 1, e ento 3n
3
+ 2n
2
n
3
para n 0.
Ex2: Seja g(n) = n, para n mpar (n 1) e g(n) = n
2
/10, para n par (n 0).
Neste caso g(n) (n
2
), bastando considerar c = 1/10 e n = 0, 2, 4, ...
0 0
), ( ) ( 0 | 0
)), ( ( ) (
n n n f n cg n c
n g n f
u > n
O =
48
Notao
A notao limita a funo por fatores constantes.
Definio: Uma funo f(n) (g(n)) se existirem constantes positivas
c
1
, c
2
e n
0
tais que 0 c
1
g(n) f(n) c
2
g(n), para todo n n
0
.
Graficamente:
Neste caso g(n) um limite superior justo (ou assinttico firme).
49
Notao
Dizemos que f(n) = (g(n)) se existirem constantes c
1
, c
2
e n
0
tais que,
para todo n n
0
, o valor de f(n) est sobre ou acima de c
1
g(n) e sobre ou
abaixo de c
2
g(n).
Isto , para todo n n
0
, a funo f(n) igual a g(n) a menos de uma
constante.
Formalmente:
Consequncia Direta: Para quaisquer funes f(n) e g(n), f(n) = g(n),
se e somente se, f(n) = O(g(n)) e f(n) = (g(n)).
0 2 1
0 2 1
n n ), n ( g c ) n ( f ) n ( g c 0
| n 0 c , 0 c )), n ( g ( ) n ( f
> V
> > n =O
50
Notao
Seja g(n) = n
2
/3 2n, provar que g(n) = (n
2
).
Temos que obter c
1
, c
2
e n
0
, tais que c
1
n
2
n
2
/3 2n c
2
n
2
para todo
n m.
Dividindo tudo por n
2
leva a c
1
1/3 2/n c
2
.
O lado direito da desigualdade ser sempre vlido para qualquer
valor de n 1 quando escolhemos c
2
1/3.
Escolhendo c
1
1/21, o lado esquerdo da desigualdade ser vlido
par qualquer valor de n 7.
Logo, escolhendo, c
1
= 1/21, c
2
= 1/3 e n
0
= 7, verifica-se que:
n
2
/3 2n = (n
2
)
Outras constantes podem existir, mas o importante que exista alguma
escolha para as trs constantes.
51
Resumo
Notao O usada para estabelecer limites superiores de
complexidade (normalmente para algoritmos).
Notao ; usada para estabelecer limites inferiores de
complexidade (normalmente para problemas).
52
Propriedades
(i) Reflexividade : f(n) = O(f(n)), f(n) = ;(f(n)), f(n) = O(f(n))
(ii) Transitividade:
Se f(n) = O(g(n)) e g(n) = O(h(n)), ento f(n) = O(h(n))
Se f(n) = ; (g(n)) e g(n) = ; (h(n)), ento f(n) = ; (h(n))
Se f(n) = O (g(n)) e g(n) = O (h(n)), ento f(n) = O (h(n))
(iii) f(n) = O(g(n)) se e somente se f(n) = O (g(n)) e f(n) = ; (g(n))
(iv) Simetria: f(n) = O(g(n)) se e somente se g(n) = O(f(n))
(v) Simetria de Transposio :
f(n) = O(g(n)) se e somente se g(n) = ;(f(n))
f(n) = ;(g(n)) se e somente se g(n) = O(f(n))
53
Notao o
Usada para definir um limite superior que no assintoticamente firme.
Definio: Uma funo f(n) o(g(n)) se, para qualquer constante c > 0,
ento: 0 e f(n) < cg(n), para todo n n
0
.
Exemplo: 2n = o(n
2
), mas 2n
2
o (n
2
).
Em f(n) = O(g(n)), a expresso 0 f(n) cg(n) vlida para alguma
constante c > 0, mas em f(n) = o(g(n)), a expresso 0 f(n) < cg(n)
vlida para todas as constantes c > 0.
Na notao o, a funo f(n) tem um crescimento muito menor que g(n)
quando n tende para infinito.
Assim, intuitivamente:
0
) (
) (
)) ( ( ) (
lim
= =

n g
n f
n g o n f
n
54
Exemplos:
T(n) = (n
3
) e T(n) = o(n
3
)
T(n) = (n
2
), mas T(n) no o(n
2
)
T(n) no (n)
2
2
lim
2
2
=
+
n
n n
x
0
2
lim
3
2
=
+
n
n n
x
=
+
n
n n
x
2
2
lim
n n n T + =
2
2 ) (
Notao o
55
Exemplos:
Caso aparea indeterminao, aplica-se Teorema de LHospital.
T(n) = (n) e T(n) = o(n)
T(n) no (log n)
n n n T + = log ) (
0
1
1
2
1
lim
Hospital se - aplica
log
lim
=
=
+

=
+

c
n
n
c
x
n
n n
x
=

=

+

=
+

=
+
c
n
x
n
c
x
n c
n
x
n
c
n n
c
x n
n n
x
lim
2
1
2
1
lim
2
1
lim
2
1
lim
log
log
lim
Notao o
56
Notao
Por analogia, a notao est relacionada com a notao ; da mesma
forma que a notao o est relacionada com a notao O.
Definio: Uma funo f(n) (g(n)) se, para qualquer constante c >
0, ento: 0 e cg(n) < f(n), para todo n n
0
.
Exemplo: n
2
/2= (n), mas n
2
/2 (n
2
).
Intuitivamente, se o limite existir:
= =

) (
) (
)) ( ( ) (
lim
n g
n f
n g n f
n
[
57
Existem dois aspectos bsicos no estudo de algoritmos:
Correo: verificao da exatido do mtodo empregado, o que
realizado atravs de uma prova matemtica.
Desempenho: obteno de parmetros que possam avaliar a
eficincia do algoritmo em termos de tempo de execuo e memria
ocupada.
A anlise de desempenho realizada atravs de um estudo do
comportamento assinttico de um algoritmo.
possvel obter a ordem de grandeza do tempo de execuo atravs de
mtodos analticos, que determinam uma expresso matemtica que
traduza o comportamento de um algoritmo.
58
As simplificaes sero introduzidas para o modelo proposto:
A quantidade de dados a ser manipulada pelo algoritmo seja
suficientemente grande, pois somente o comportamento assinttico
ser avaliado.
No sero consideradas constantes aditivas ou multiplicativas.
Hipteses do modelo de computao (AHO, HOPCROFT & ULMAN,
1983):
Operaes elementares: comparaes (lgicas e relacionais),
atribuies e operaes aritmticas.
Operaes elementares gastam uma unidade de tempo.
59
1. O tempo de execuo de um comando de atribuio, de entrada ou
de sada O(1) ou O(k), sendo k constante.
2. O tempo de execuo de um comando de deciso simples
composto pelo tempo para avaliar a condio (que O(1)) mais o
tempo dos comandos executados dentro da condio.
Neste caso, ser executada a seqncia de comandos 1 ou a seqncia
de comandos 2. Assim, a complexidade de pior caso dada por
Max(seq1, seq2).
Princpios de Anlise de Algoritmos
if (condio){
sequncia de comandos 1;
}
else{
}
if (condio){
}
else{
}
60
3. O tempo para executar um comando de repetio a soma do
tempo de execuo do corpo do lao mais o tempo de avaliar a
condio de parada (geralmente O(1)) multiplicado pelo nmero de
iteraes do lao.
O lao acima executado n vezes, logo a seqncia de comandos
executada tambm n vezes. Assumindo que a seqncia de comandos
O(1), o tempo total para o loop n*O(1), ou seja, O(n).
for (int i = 0; i < n; i++){
seqncia de comandos;
}
for (int i = 0; i < n; i++){
}
61
O lao mais externo executa n vezes. Cada vez que ele executado, o
lao mais interno executa m vezes.
Como resultado a seqncia de comandos no lao mais interno
executa do n*m vezes. Assim, a complexidade O(n*m).
Se a condio de parada do lao mais interno fosse n, ao invs de m, a
complexidade do trecho acima seria O(n
2
), ou seja, complexidade
quadrtica.
for (int i = 0; i < n; i++){
for (int j = 0; j < m; j++){
}
for (int i = 0; i < n; i++){
for (int j = 0; j < m; j++){
}
62
Algoritmo para inverso de uma seqncia de n elementos:
3n/2 operaes
Algoritmo (n)
n = 1.000 1.500 instrues
n = 2.000 3.000 instrues
n = 4.000 6.000 instrues
existe uma dependncia linear
Inverso de Seqncia
package cap1;
public class InverteSequencia {
public static void inverteSequencia(int v[], int n){
int temp;
for (int i = 0; i < n/2; i++){
temp = v[i];
v[i] = v[ni1];
v[ni1] = temp;
}
}
}
package cap1;
public class InverteSequencia {
public static void inverteSequencia(int v[], int n){
int temp;
for (int i = 0; i < n/2; i++){
temp = v[i];
v[i] = v[ni1];
v[ni1] = temp;
}
}
}
63
Algoritmo para soma de matrizes de ordemn:
2n
2
operaes
Algoritmo (n
2
)
n = 1.000 2.000.000 instrues
n = 2.000 8.000.000 instrues
n = 4.000 32.000.000 instrues
h uma dependncia quadrtica
Soma de Matrizes
package cap1;
public class SomaMatrizes {
public static void somaMatrizes(int a[][], b[][], c[][],int n){
for(int i = 0; i < n; i++)
for(int j = 0; j < n; j++){
c[i][j] = a[i][j] + b[i][j];
}
}
}
package cap1;
public class SomaMatrizes {
public static void somaMatrizes(int a[][], b[][], c[][],int n){
for(int i = 0; i < n; i++)
for(int j = 0; j < n; j++){
c[i][j] = a[i][j] + b[i][j];
}
}
}
64
Algoritmo para produto de matrizes de ordem n :
3n
3
+ n
2
operaes
Algoritmo (n
3
)
n = 1.000 3.001.000.000 instrues
n = 2.000 24.004.000.000 instrues
n = 4.000 192.016.000.000 instrues
h uma dependncia cbica
Produto de Matrizes
package cap1;
public class ProdutoMatrizes {
public static void produtoMatrizes(int a[][], b[][], c[][],int n){
for(int i = 0; i < n; i++)
for(int j = 0; j < n; j++){
c[i][j] = 0;
for(int k = 0; k < n; k++)
c[i][j]=c[i][j]+a[i][k]*b[k][j];
}
}
}
package cap1;
public class ProdutoMatrizes {
public static void produtoMatrizes(int a[][], b[][], c[][],int n){
for(int i = 0; i < n; i++)
for(int j = 0; j < n; j++){
c[i][j] = 0;
for(int k = 0; k < n; k++)
c[i][j]=c[i][j]+a[i][k]*b[k][j];
}
}
}
65
Limites Inferiores e
Algoritmos timos
Um limite inferior para um problema P uma funo f tal que a
complexidade de pior caso de qualquer algoritmo que resolve P ;(f).
Seja um problema P e A um algoritmo que resolve este problema P. Se P
;(f) e A resolve P em O(f), ento o algoritmo assintoticamente timo.
O algoritmo que soma matrizes assintoticamente timo j que sua
complexidade de pior caso O(n
2
) e o problema de somar matrizes
;(n
2
).
O algoritmo que multiplica matrizes com complexidade O(n
3
) no
timo j que existe um algoritmo que multiplica matrizes em O(n
2.38
).
No sabido se este ltimo algoritmo timo.
66
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. Nesses casos, o
comportamento assinttico no serve para comparar os algoritmos.
Por exemplo, considere dois algoritmos F e G aplicados 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.
67
Um programa com tempo O(n) melhor que outro com tempo O(n
2
).
Porm, as constantes de proporcionalidade podem alterar esta
considerao.
Exemplo: um programa leva 100n unidades de tempo para ser
executado e outro leva 2n
2
. Qual dos dois programas melhor?
Para n < 50, o programa com tempo 2n
2
melhor do que o que
possui tempo 100n.
Para problemas com entrada de dados pequena prefervel usar o
programa cujo tempo de execuo O(n
2
).
Entretanto, quando n cresce, o programa com tempo de execuo
O(n
2
) leva muito mais tempo que o programa O(n).
68
Principais Classes de Problemas
Complexidade Constante (f(n) = (1)):
O uso do algoritmo independe do tamanho de n;
As instrues do algoritmo so executadas um nmero fixo de
vezes.
Complexidade Logartmica (f(n) = (log n)):
ocorre tipicamente em algoritmos que transformam um problema
em outros menores;
Pode-se considerar o tempo de execuo como menor que uma
constante grande;
log
2
1000 10 e log
2
1000000 20 e a base influencia pouco;
Ex: Pesquisa Binria
69
Complexidade Linear (f(n) = (n)):
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;
Ex: Pesquisa Sequencial.
Complexidade Linear-Logartmica (f(n) = (nlog n)):
Tpico em problemas que quebram um problema em outros
menores, resolvem cada um deles independentemente e juntam as
solues depois;
Ex: Ordenao Rpida (Quicksort).
70
Complexidade Quadrtica (f(n) = (n
2
)):
Ocorrem quando os itens de dados so processados aos pares,
muitas vezes em um lao dentro de outro;
Quando n 1000, o nmero de operaes da ordem de 1 milho.
Sempre que n dobra, o tempo de execuo multiplicado por 4.
Ex: Soma de Matrizes.
Complexidade Cbica (f(n) = (n
3
)):
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.
Ex: Multiplicao de Matrizes.
71
Complexidade Exponencial (f(n) = (2
n
)):
Geralmente no so teis sob o ponto de vista prtico.
Quando n 20, o tempo de execuo cerca de 1 milho.
Quando n dobra, o tempo fica elevado ao quadrado.
Ex: Simplex para Otimizao.
Complexidade Fatorial (f(n) = (n!)):
Tambm dito ter complexidade exponencial, apesar de O(n!) ter
comportamento muito pior do que O(2
n
).
Ocorrem quando se usa fora bruta na soluo do problema.
n = 20 20! = 2432902008176640000 (19 dgitos).
n = 40! um nmero com 48 dgitos.
Ex: Problema do Caixeiro Viajante.
72
Comparao de Funes de
Complexidade
Funo
de Custo
Tamanho de n
10 20 30 40 50 60
n 0,00001
seg.
0,00002
seg.
0,00003
seg.
0,00004
seg.
0,00005
seg.
0,00006
seg.
n
2
0,0001
seg.
0,0004
seg.
0,0009
seg.
0,0016
seg.
0,0025
seg.
0,0036
seg.
n
3
0,001
seg.
0,008
seg.
0,027
seg.
0,064
seg.
0,125
seg.
0,216
seg.
n
5
0,1
seg.
3,2
seg.
24,3
seg.
1,7
min.
5,2
min.
13
min.
2
n
0,001
seg
1
seg.
17,9
min.
12,7
dias
35,7
anos
366
sc.
3
n
0,059
seg.
58
min.
6,5
anos
3855
sc.
10
8
sc.
10
13
sc.
Estudo de Garey & Johnson (1979) com computadores que executam
um milho de operaes por segundo.
Comparao de Funes de
Complexidade
73
A tabela mostra como um aumento de 100 ou de 1000 vezes na
velocidade do processador influi na soluo do maior problema
possvel de ser resolvido em uma hora.

Introdução À Análise de Algorítmos

Загружено:

Сведения о документе

Оригинальное название

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

Introdução À Análise de Algorítmos

Загружено:

Авторское право:

Доступные форматы

Captulo I Introduo Anlise

Вам также может понравиться