Aula05 AnaliseAssintotica

5.
Anlise Assinttica
Introduo Limites Assintticos Anlise Assinttica de Algoritmos Principais Classes de Algoritmos Algoritmos Polinomiais x Exponenciais Complexidade Logartmica Eficincia tima Anlise Assinttica Multivarivel
5. Anlise Assinttica
- Introduo
-2-
- Introduo
-3-
- Introduo
-4-
- Introduo
Taxa de Crescimento de Funes
uma abstrao que facilita a anlise da complexidade computacional de um algoritmo. Enfoca o que realmente importante para a tomada de deciso quanto ao algoritmo a ser utilizado. Descreve de forma compacta como o custo do algoritmo (tempo de processamento ou consumo de memria) cresce com a quantidade de dados processados.
-5-
- Introduo
Como determinar a taxa de crescimento ?
O que realmente nos interessa o comportamento do algoritmo para valores grandes de n.
Para pequena quantidade de dados, normalmente qualquer algoritmo rpido, mesmo os ineficientes.
Considerar apenas o termo que cresce mais rpido em funo de n nas expresses que descrevem os custos T(n) e M(n) , desprezando os termos de menor ordem. Ignorar constantes multiplicativas. -6-
- Introduo
Exemplo: pior caso do algoritmo InsertionSort T(n) = c2 n2 + c1 n + c0
Desprezar termos de crescimento mais lento
T(n) c2 n2
Ignorar constantes multiplicativas T(n) pertence classe das funes que crescem como n2, ou seja, das funes com taxa de crescimento quadrtica.
T(n)
(n2) -7-
- Introduo
Por que desprezamos termos de menor ordem ?
n 10 100 1.000 10.000 100.000 2n2 + 5n + 8 258 20.508 2.005.008 200.050.008 20.000.500.008 2n2 20.000 2.000.000 200.000.000 20.000.000.000 Erro 200 22,481% 2,477% 0,250% 0,025% 0,002% 0,000%
1.000.000 2.000.005.000.008 2.000.000.000.000
-8-
- Introduo
Por que desprezamos termos de menor ordem ?
25000
25000000000
20000
20000000000
15000
15000000000
10000
10000000000
5000000000
5000
0 0 8000 16000 24000 32000 40000 48000 56000 64000 72000 80000 88000
0 100 10 15 20 25 30 35 40 45 50 55 60 65 70 75 80 85 90 95 0 5
-9-
96000
- Introduo
Por que ignoramos constantes multiplicativas ?
Imagine dois algoritmos A e B com tempos de execuo TA(n) = 3n2 e TB(n) = 6n2. Os dois algoritmos tm a mesma taxa de crescimento. Em uma mesma mquina, A rodar sempre 2 vezes mais rpido que B, para qualquer quantidade de dados n. Se estes algoritmos forem executados em uma mquina 3 vezes mais rpida, os tempos de execuo passaro a ser TA(n) = n2 e TB(n) = 2n2. CONCLUSO: a constante multiplicativa depende apenas da plataforma de execuo, e no do algoritmo !!! - 10 -
- Introduo
Considere 5 algoritmos cuja taxa de crescimento da funo T(n) corresponda s funes f1(n) a f5(n) na tabela abaixo, supondo que cada operao demore 1 milsimo de segundo.
O que acontecer se o algoritmo 5 for executado para uma entrada de dados de tamanho n=512 em um computador 1 bilho de vezes mais rpido ?
- 11 -
- Introduo
O tempo de processamento ser reduzido 1 bilho de vezes.
- 12 -
- Introduo
O tempo de processamento ser reduzido 1 bilho de vezes. Executar em apenas 10128 sculos em vez de 10137 sculos !
- 13 -
- Introduo
Comparao entre diferentes taxas de crescimento
( supondo que cada passo do algoritmo consome 1 s )
- 14 -
- Introduo
Eficincia de um algoritmo
Dados dois algoritmos que resolvem um mesmo problema, dizemos que um algoritmo mais eficiente que o outro quando sua funo de custo (tempo de execuo e/ou consumo de memria) tem uma taxa de crescimento inferior do outro algoritmo.
Mas ... como comparar taxas de crescimento ?

Estudando o comportamento assinttico das funes e estabelecendo limites assintticos para a taxa de crescimento. - 15 -
- Introduo
Comportamento Assinttico de Funes O parmetro n e a taxa de crescimento T(n) fornecem uma medida do esforo computacional necessrio para se resolver o problema. Para valores suficientemente pequenos de n, qualquer algoritmo custa pouco para ser executado, mesmo os ineficientes.
- 16 -
- Introduo
Comportamento Assinttico de Funes Portanto, a escolha do algoritmo no um problema crtico para problemas de tamanho pequeno. Por isso, a anlise de algoritmos realizada para valores grandes de n.
- 17 -
- Introduo
Comportamento Assinttico de Funes Estuda-se o comportamento assinttico das funes de custo referentes a tempo de execuo e a consumo de memria
o comportamento das funes T(n) e M(n) para valores grandes de n
Os comportamentos assintticos de T(n) e M(n) representam o limite do comportamento do custo do algoritmo quando n cresce.
- 18 -
- Limites Assintticos
Limites Assintticos So uma maneira compacta de expressar o custo (tempo de execuo ou consumo de memria) de um algoritmo. So tambm uma maneira de comparar algoritmos de forma qualitativa e independente da implementao (hardware/compilador).
- 19 -
Limites Assintticos O() = limite assinttico superior () = limite assinttico inferior () = limite assintoticamente restrito o() = limite assinttico superior estrito () = limite assinttico inferior estrito
- 20 -
Limites Assintticos f(n) O(g(n)) f(n) cresce com taxa menor ou igual a g(n) f(n) (g(n)) f(n) cresce com taxa maior ou igual a g(n)
f(n) (g(n)) f(n) cresce com a mesma taxa que g(n) f(n) o(g(n)) f(n) cresce com taxa menor que g(n) f(n) (g(n)) f(n) cresce com taxa maior que g(n)
- 21 -
Limites Assintticos Premissa: nas definies dos limites assintticos, supe-se que as funes T(n) e M(n) sejam funes assintoticamente no-negativas, ou seja, que exista um valor no tal que T(n), M(n) 0 para todo n no. Esta premissa sempre verdadeira na prtica, visto que a quantidade de dados processados n, o tempo de processamento T(n) e o consumo de memria M(n) so sempre valores positivos.
- 22 -
Limites Assinttico Superior O()
O(g(n)) = { f(n) : existem constantes positivas c e n0 tais que 0 f(n) cg(n) para todo n n0 } Se f(n) O(g(n)) , ento g(n) um limite assinttico superior para f(n). f(n) cresce no mximo to rapidamente quanto g(n). Condio suficiente:
- 23 -
O(g(n)) = { f(n) : existem constantes positivas c e n0 tais que 0 f(n) cg(n) para todo n n0 }
- 24 -
Limites Assinttico Inferior ()
(g(n)) = { f(n) : existem constantes positivas c e n0
tais que 0 cg(n) f(n) para todo n n0 } Se f(n)

(g(n)) , ento
g(n) um limite assinttico inferior para f(n) . f(n) cresce no mnimo to rapidamente quanto g(n). Condio suficiente:
- 25 -
(g(n)) = { f(n) : existem constantes positivas c e n0
tais que 0 cg(n) f(n) para todo n n0 }
- 26 -
Limites Assintoticamente Restrito () (g(n)) = { f(n) : existem constantes positivas c1, c2 e n0
tais que 0 c1 g(n) f(n) c2 g(n) p/ todo n n0 } Se f(n) (g(n)) , ento g(n) um limite assintoticamente restrito de f(n). f(n) cresce to rapidamente quanto g(n). Condio suficiente :
- 27 -
Limites Assintoticamente Restrito () (g(n)) = { f(n) : existem constantes positivas c1, c2 e n0
tais que 0 c1 g(n) f(n) c2 g(n) p/ todo n n0 }
- 28 -
Limites Assinttico Superior Estrito o()
o(g(n)) = { f(n) : para qualquer constante c > 0, existe n0 > 0 tal que 0 f(n) cg(n) para todo n n0 } Se f(n) o(g(n)) , ento g(n) um limite assinttico superior estrito para f(n). f(n) cresce menos rapidamente que g(n). Condio suficiente:
- 29 -
Limites Assinttico Superior Estrito o()
o(g(n)) = { f(n) : para qualquer constante c > 0, existe n0 > 0 tal que 0 f(n) cg(n) para todo n n0 }
- 30 -
Limites Assinttico Inferior Estrito () (g(n)) = { f(n) : para qualquer constante c > 0, existe n0 > 0
tal que 0 cg(n) f(n) para todo n n0 } Se f(n) (g(n)) , ento g(n) um limite assinttico inferior estrito para f(n) . f(n) cresce mais rapidamente que g(n). Condio suficiente:
- 31 -
Limites Assinttico Inferior Estrito () (g(n)) = { f(n) : para qualquer constante c > 0, existe n0 > 0
tal que 0 cg(n) f(n) para todo n n0 }
- 32 -
Se existir, ento:
- 33 -
Determinao dos Limites Assintticos em funo de :
zero
f(n) o(g(n)) f(n) O(g(n)) f(n) O(g(n)) f(n) (g(n)) f(n) (g(n)) f(n) (g(n)) f(n) (g(n))
positivo finito
infinito - 34 -
- 35 -
- 36 -
- 37 -
- 38 -
Limites Assintoticamente Restrito ()
- 39 -
- 40 -
- 41 -
Analogia com Operadores Relacionais f(n) O(g(n)) f(n) g(n) f(n) (g(n)) f(n) g(n)
(assintoticamente menor ou igual) (assintoticamente maior ou igual) (assintoticamente igual) (assintoticamente menor) (assintoticamente maior)
f(n) (g(n)) f(n) = g(n) f(n) o(g(n)) f(n) < g(n) f(n) (g(n)) f(n) > g(n)
Algumas propriedades so muito semelhantes . . . - 42 -
- Limites Assintticos Transitividade
Se f(n) O(g(n)) e g(n) O(h(n)), ento f(n) O(h(n)) f(n) g(n) h(n) Se f(n)
(g(n)) e g(n) (h(n)), ento f(n) (h(n)) f(n) g(n) h(n)
Se f(n) (g(n)) e g(n) (h(n)), ento f(n) (h(n)) f(n) = g(n) = h(n) Se f(n) o(g(n)) e g(n) o(h(n)), ento f(n) o(h(n)) f(n) < g(n) < h(n) Se f(n) (g(n)) e g(n) (h(n)), ento f(n) (h(n)) f(n) > g(n) > h(n) - 43 -
- Limites Assintticos Reflexividade
f(n) O(f(n)) f(n)
(f(n))
f(n) f(n) f(n) f(n) f(n) = f(n)
f(n) (f(n))
No vlida para o() e () .
- 44 -
- Limites Assintticos Simetria
f(n) (g(n)) se e somente se g(n) (f(n)) No vlida para O() ,
() , o() e () .
f(n) = g(n)
- 45 -
- Limites Assintticos Simetria de Transposio
f(n) O(g(n)) se e somente se g(n)
(f(n))
f(n) g(n) f(n) < g(n)
f(n) o(g(n)) se e somente se g(n) (f(n)) Somente estas duas formas so vlidas.
- 46 -
- Limites Assintticos Tricotomia
Para nmeros reais a e b, uma e somente dentre as afirmaes a seguir so verdadeiras: a<b ou a=b ou a>b
No caso de funes assintoticamente no-negativas f(n) e g(n), a tricotomia f(n) o(g(n)) ou f(n) (g(n)) ou f(n) (g(n)) s vlida se existir.
- 47 -
Exemplo: n1+sen(n) no o(g(n)) nem (g(n)) e nem (g(n)).
- 48 -
Exemplo: n1+sen(n) no o(g(n)) nem (g(n)) e nem (g(n)). Porm, a tricotomia vlida quando aplicada s funes que descrevem a taxa de crescimento da maioria dos algoritmos (polinmios, logaritmos e exponenciais).
- 49 -
f(n) (g(n))
se e somente se
f(n) == g(n)
f(n) O(g(n)) e f(n)

f(n) g(n)
(g(n))
f(n) g(n)
- 50 -
- Limites Assintticos Convenes (abuso de notao):
1. Igual a conjunto significa pertence ao conjunto f(n) = O(g(n)) f(n) O(g(n)) 2. Um conjunto inserido em uma frmula representa uma funo qualquer pertencente ao conjunto. f(n) = n3 + O(n2) f(n) = n3 + h(n) onde h(n) O(n2) n2 + O(n) = O(n2) para todo f(n) O(n), n2 + f(n) = h(n), onde h(n) O(n2)
- 51 -
- Limites Assintticos Regra da Soma: O(f(n)) + O(g(n)) = O( max(f(n),g(n)) ) (f(n)) + (g(n)) = ( max(f(n),g(n)) ) (f(n)) + (g(n)) = ( max(f(n),g(n)) ) o(f(n)) + o(g(n)) = o( max(f(n),g(n)) ) (f(n)) + (g(n)) = ( max(f(n),g(n)) )
- 52 -
- 53 -
- Limites Assintticos Regra da Multiplicao: O(f(n)).O(g(n)) = O(f(n).g(n)) (f(n)). (g(n)) = (f(n).g(n)) (f(n)).(g(n)) = (f(n).g(n)) o(f(n)).o(g(n)) = o(f(n).g(n)) (f(n)).(g(n)) = (f(n).g(n))
- 54 -
- Limites Assintticos Regra da Multiplicao
- 55 -
- Anlise Assinttica de Algoritmos
Regras para Anlise Assinttica de Algoritmos Para analisar algoritmos muito complexos, necessitamos de regras que nos permitam estabelecer os limites assintticos hierarquicamente. Comeamos analisando a complexidade dos laos mais internos e em seguida dos mais externos, at obter a complexidade do algoritmo como um todo.
- 56 -
- Anlise Assinttica de Algoritmos Algumas regras teis:
Blocos em seqncia Laos com nmero de fixo de iteraes Laos com nmero varivel de iteraes Laos aninhados
- 57 -
Caso 1 Blocos em Seqncia
Bloco com complexidade T1(n) seguido de bloco com complexidade T2(n) . A complexidade total do conjunto dada por
T1(n)
T(n)
T2(n)
T(n) = T1(n) + T2(n) = O(T1(n)) + O(T2(n)) = O( max(T1(n),T2(n)) ) Exemplo: T1(n) = 3n2 + 8 = O(n2) T2(n) = 2n + 12 = O(n) -------------------------------------T (n) = 3n2 + 2n + 20 = O(n2)
- 58 -
Caso 2 Lao com nmero fixo de iteraes
Lao que executa k vezes um bloco com complexidade T1(n) . A complexidade total do conjunto dada por
Repetir k vezes {
T1(n)
}
T(n)
T(n) = k.T1(n) = O(T1(n)) Exemplo: T1(n) = 3n2 + 8 = O(n2) ------------------------------------T (n) = 3kn2 + 8k = O(n2)
- 59 -
Caso 3 Lao com nmero varivel de iteraes
Lao que executa K1(n) vezes um bloco com complexidade T1(n) . Repetir K1(n) vezes { A complexidade total do conjunto dada por T(n) = K1(n)T1(n) = O(K1(n)T1(n)) = O(K1(n)) . O(T1(n)) Exemplo: K1(n) = n = O(n) T1(n) = 3n2 + 8 = O(n2) -------------------------------------T (n) = 3n3 + 8n = O(n3)
T1(n)
}
T(n)
- 60 -
Caso 4 Laos aninhados
Lao externo que executa K1(n) vezes um lao interno, que por sua vez executa K2(n) vezes um bloco de complexidade T1(n) . Repetir K1(n) vezes { Repetir K2(n) vezes { A complexidade total do conjunto dada por T(n) = K1(n).K2(n).T1(n) = O(K1(n).K2(n).T1(n)) = O(K1(n)) . O(K2(n)) . O(T1(n)) Exemplo: K1(n) = 2n = O(n) K2(n) = log2n = O(log n) T1(n) = 5n2 = O(n2) -------------------------------------------T (n) = 10n3 log2n = O(n3 log n)
T1(n)
} }
T(n)
- 61 -
Exemplo: Soma de Matrizes Quadradas
para linha i = 1,2,3,,n
O(n)
para coluna j = 1,2,3,,n O(n) xij aij + bij O(1) fim colunas fim linhas
O(n) . O(n) . O(1) = O(n2)

- 62 -
Exemplo: Multiplicao de Matrizes Quadradas
para linha i = 1,2,3,,n para coluna j = 1,2,3,,n xij 0 xij xij + aik * bkj O(1) fim elementos fim colunas fim linhas
O(n) O(n)
para elementos k = 1,2,3,,n O(n)
O(n) . O(n) . O(n) . O(1) = O(n3)

- 63 -
Verificao experimental da taxa de crescimento do tempos de execuo dos algoritmos de soma e multiplicao de matrizes :
Experimento 5.1 Experimento 5.2
- 64 -
Complexidade Assinttica de um Algoritmo
O tempo de execuo de um algoritmo dito ser O(g(n)) se a funo T(n) que descreve o seu crescimento for O(g(n)) no pior caso. O tempo de execuo de um algoritmo dito ser (g(n)) se a funo T(n) que descreve o seu crescimento for (g(n)) no melhor caso. O tempo de execuo de um algoritmo dito ser (g(n)) quando o algoritmo simultaneamente O(g(n)) e (g(n)). O mesmo vale para consumo de memria. - 65 -
Complexidade Assinttica de um Algoritmo Exemplos:
Os algoritmos Soma, Max e MediaFinal so (n). O algoritmo InsertionSort O(n2) e (n).
O algoritmo de soma de matrizes quadradas (n2). O algoritmo de multiplicao de matrizes (n3).
- 66 -
- 67 -
- 68 -
- Principais Classes de Algoritmos
Principais Classes de Algoritmos O limite inferior estrito o(.) induz uma ordem crescente de complexidade assinttica, dividindo os algoritmos em classes conforme a complexidade de sua funo de custo:
c = o(log(n)) ; log(n) = o(n) ; n = o(n2), etc. ou seja: c < log n < n < n.log(n) < n2 < n3 < cn - 69 -
- 70 -
- 71 -
- 72 -
- 73 -
- 74 -
- 75 -
- 76 -
- 77 -
- 78 -
- Algoritmos Polinomiais x Exponenciais
- 79 -
- 80 -
- 81 -
- 82 -
O Problema do Caixeiro Viajante
- 83 -
- 84 -
- 85 -
- 86 -
Comparao entre algumas classes
( supondo que cada passo do algoritmo consome 1 s )
- 87 -
Tamanho do problema que pode ser resolvido com um computador mais rpido:
- 88 -
- Complexidade Logartmica
Algoritmos de Complexidade Logartmica Em muitas situaes, possvel se reduzir a complexidade de um lao iterativo de O(n) para O(log n) quando os elementos a serem verificados esto dispostos em ordenao conhecida. Como exemplo, vamos considerar o problema da pesquisa de um elemento especfico em um array.
- 89 -
Pesquisa de um elemento especfico em um array Dado um array com n elementos x0, x1, x2, , xn-1, determinar a posio do elemento cuja chave de identificao tem um valor especfico v. Vamos comparar dois algoritmos: Pesquisa Sequencial Pesquisa Binria
- 90 -
Pesquisa Sequencial Comeando pelo primeiro elemento, verificar elemento a elemento, seqencialmente, at encontrar o elemento procurado, e ento retornar o valor da posio do elemento. Caso o final do array seja atingido sem que o elemento procurado tenha sido encontrado, retornar uma indicao de que o elemento est ausente da lista (por exemplo: valor -1).
- 91 -
Pesquisa Sequencial
Pseudo-Linguagem
obter x0,x1,,xn-1 obter v para i=0,1,,n-1 se xi == v retornar i retornar -1
Linguagem de Programao
int pesquisar(float[] x, int n, int v) { for (int i=0; i<n; i++) { if (x[i] == v) return i; } return -1; }
Procurar por R A C E H L M P R T Z
- 92 -
Anlise da Pesquisa Seqencial Pesquisa com sucesso
Melhor caso: Pior caso: Melhor caso: elemento encontrado na posio 0 1 elemento verificado O(1) elemento encontrado na posio n-1 n elementos verificados O(n) elemento em posio aleatria mdia de (n+1)/2 verificaes n elementos verificados - 93 O(n) O(n)
Pesquisa sem sucesso:
Ordenao dos dados X Eficincia na pesquisa
Imaginem algum usando pesquisa seqencial para localizar um assinante especfico em uma lista telefnica com 2 milhes de assinantes ! Em mdia 1 milho de nomes teriam que ser verificados ! Como conseguimos achar um nome especfico to rapidamente em meio a milhes ? Resposta: usamos um algoritmo mais eficiente, tirando proveito do fato de a lista estar ordenada. Se a lista no estivesse ordenada, no haveria algoritmo melhor que a busca seqencial. - 94 -
Ordenao dos dados X Eficincia na pesquisa
Embora O(n) no seja uma taxa de crescimento ruim, quando comparada a outras que vimos, a pesquisa de elementos especficos freqentemente parte integrante de outros algoritmos mais complexos. muito desejvel reduzir essa taxa para O(log n). Isso possvel quando os elementos esto ordenados ! Em muitas situaes, vale a pena o custo de ordenar os dados e mant-los ordenados ao longo de atualizaes, em troca do aumento de eficincia na pesquisa. - 95 -
Pesquisa Binria
vlido apenas para listas ordenadas
Comparar o elemento situado no meio do array com o elemento procurado. Se este elemento tiver valor maior que o elemento procurado, ento o elemento est na 1 metade do array. Se este elemento tiver valor menor que o elemento procurado, ento o elemento est na 2 metade do array. Repetir o processo sobre a metade selecionada do array, at que o elemento procurado seja encontrado, ou at restar 1 nico elemento diferente do elemento procurado. - 96 -
Pesquisa Binria
Pseudo-Linguagem
obter x0,x1,,xn-1 obter v i 0 f n-1 Enquanto i <= f m (i+f)/2 se v = xm , retornar m se v < xm , f m-1 seno i m+1 retornar -1
Linguagem de Programao
int pesquisar(float[] x, int n, int v) { int inicio = 0, fim = n-1, meio; while (inicio <= fim ) { meio = (inicio+fim)/2; if (v == x[meio]) return meio; if (v < x[meio]) fim = meio-1; else inicio = meio+1; } return -1; }
X
- 97 -
Anlise da Pesquisa Binria A cada iterao, o nmero de elementos a pesquisar cai metade:
Elementos pendentes Incio n = n / 20 Iterao 1 n / 2 = n / 21 Iterao 2 n / 4 = n / 22 Iterao 3 n / 8 = n / 23 Iterao k n / 2k - 98 -
Anlise da Pesquisa Binria No pior caso, a ltima iterao ocorre quando resta apenas 1 elemento a pesquisar, ou seja, quando
n / 2k = 1
Logo, o nmero mximo de iteraes que podem ocorrer dado por
kmax = log2 n + 1 = O(log n)

- 99 -
Anlise da Pesquisa Binria
obter x0,x1,,xn-1 obter v i 0 f 0 Enquanto i <= f m (i+f)/2 se v = xm , retornar m se v < xm , f m-1 seno i m+1 retornar -1
O(log n) iteraes Custo O(1) por iterao
O algoritmo tem limite superior
O(log n) O(1) = O(log n)

- 100 -
Comparao Pesquisa Binria X Sequencial
Qtde Elementos n 100 1.000 10.000 100.000 1.000.000 1.000.000.000 Caso Mdio P. Sequencial n/2 50 500 5.000 50.000 500.000 500.000.000 Pior Caso P. Binria log2 n + 1 7 10 14 17 20 30 40
1.000.000.000.000 500.000.000.000 - 101 -
Resumo: A pesquisa sequencial O(n) e A pesquisa binria O(log n) e (1). (1).
- 102 -
Consideraes sobre a Pesquisa Binria A pesquisa binria s possvel quando os dados esto ordenados. O custo para manter os dados ordenados em um array de O(n) a cada novo elemento inserido. Assim, o baixo custo O(log n) da pesquisa binria em arrays tem como contrapartida um custo O(n) na insero de novos elementos.
- 103 -
Consideraes sobre a Pesquisa Binria Portanto, a vantagem da pesquisa binria s se manifesta na prtica nos seguintes casos:
Quando a insero de novos elementos rara, enquanto que a necessidade de pesquisa freqente. Quando o tempo de execuo da pesquisa crtico para os requisitos do sistema, mas o tempo consumido na insero de novos elementos no crtico.
Para obter complexidade logartmica tanto na insero quanto na localizao de elementos, podem ser usadas rvores binrias balanceadas.
- 104 -
- Eficincia tima
Algoritmo timo
Um algoritmo dito ser timo* quando, dentre todos os possveis algoritmos capazes de resolver um mesmo problema, ele o que apresenta a menor complexidade assinttica no pior caso.
* assintoticamente timo ou de eficincia tima
- 105 -
- Eficincia tima
Algoritmo timo
Suponhamos que g(n) seja uma funo que estabelece um limite inferior natural para a taxa de crescimento do tempo de execuo de um problema P, determinado por meio de anlise direta do problema. Nesse caso, qualquer algoritmo capaz de resolver o problema P executar um nmero mnimo de (g(n)) passos. Se um algoritmo A capaz de resolver P em tempo de execuo O(g(n)), ento A um algoritmo timo.
- 106 -
- Eficincia tima
Exemplos
Somar todos os elementos de um array
Limite inferior natural do problema: (n) Complexidade do algoritmo proposto: O(n) O algoritmo proposto timo
Somar matrizes quadradas

Limite inferior natural do problema: (n2) Complexidade do algoritmo proposto: O(n2) O algoritmo proposto timo
Multiplicar matrizes quadradas

Limite inferior natural do problema: (n2) Complexidade do algoritmo proposto: O(n3) O algoritmo proposto no timo - 107 -
5. Anlise Assinttica - Eficincia tima

Cota superior e inferior de um problema
- 108 -

- 109 -

- 110 -

- 111 -

- 112 -
- Eficincia tima
Problemas em Aberto
Para muitos problemas, a obteno de limites inferiores no nada fcil. A pesquisa de algoritmos timos uma das reas mais importantes da Cincia da Computao. H muitos problemas importantes para os quais o limite inferior no conhecido. Um exemplo so os problemas da Classe NP. - 113 -
- Eficincia tima
Problemas em Aberto
Exemplo: problemas da classe NP
Nunca se conseguiu obter um algoritmo polinomial para problemas desta classe Por outro lado, tambm nunca foi demonstrado que seja impossvel se construir tais algoritmos (nunca foi demonstrada uma cota inferior supra-polinomial). H um prmio de 1 milho de libras para quem esclarecer esta questo (ver www.claymath.org). Questo formulada em 1971 e sem resposta at hoje. - 114 -
- Eficincia tima
Exerccio:
Encontrar um algoritmo timo para resolver o problema abaixo: Dada uma lista com n valores x0, x1, x2, , xn-1 distintos e ordenados em ordem crescente, determinar a quantidade de pares ( xi ; xj ) cuja soma corresponda a um valor s, ou seja, xi + xj = s.
- 115 -
- Eficincia tima
Tentativa 1 : verificar cada possvel par
int qtdPares( float[] x, int n, float s ) { int qtd = 0; for (int i=0; i<n-1; i++) { for (int j=i+1; j<n; j++) { if ( x[i]+x[j] == s ) qtd++; } } return qtd; }
O(n) O(n) O(1) O(n2)
- 116 -
- Eficincia tima
Tentativa 2 :
Utilizar uma adaptao da pesquisa binria para reduzir a complexidade do lao interno de O(n) para O(log n).
int qtdPares( float[] x, int n, float s ) { int soma, qtd = 0; for (int i=0; i<n-1; i++) { ini = i+1; fim = n-1; while (ini <= fim) { j = (ini+fim)/2; soma = x[i] + x[j]; if ( soma == s ) { qtd++; break; } if ( soma < s ) ini = j + 1; else fim = j - 1; } } return qtd; } - 117 -
O(n) O(log n) O(1) O(n.log n)
- Eficincia tima
Tentativa 3 :
Utilizar um nico lao, com dois ponteiros percorrendo o array em sentidos opostos:
int qtdPares( float[] x, int n, float s ) { int soma, qtd=0, i=0, j=n-1; while (i<j) O(n) { soma = x[i] + x[j]; if (soma <= s) i++; O(1) if (soma >= s) j--; if (soma == s) qtd++; } return qtd; }
O(n)
- 118 -
- Eficincia tima
Freqentemente construmos algoritmos de baixa eficincia por no percebermos aspectos da estrutura dos dados que podem ser explorados para construir um algoritmo mais eficiente. Dicas:
Explorar possibilidades de ordenao dos dados de modo a reduzir a complexidade de laos de pesquisa. Procurar identificar e eliminar passos de processamento redundantes - 119 -
- Eficincia tima
Dicas (continuao):
Muitas vezes vale a pena pagar o custo de O(n.log n) de um algoritmo de ordenao para pr-ordenar os dados e ganhar eficincia no processamento posterior. Exemplo: suponha uma variante do problema anterior em que a lista de valores no esteja ordenada. Somente o algoritmo O(n2) da tentativa 1 funcionaria com a lista no-ordenada. Mas se utilizarmos um algoritmo de ordenao de custo O(n.log n) e em seguida resolvermos o problema pelo algoritmo O(n) da tentativa 3, o custo total ser O(n.log n), que muito melhor do que O(n2). - 120 -
- Eficincia tima
Dicas (continuao):
Outro aspecto importante procurar explorar a estrutura do problema (especialmente em problemas matemticos e em problemas envolvendo grafos e redes). Exemplo: calcular a soma de todos os nmeros inteiros de 1 a n
int somatorio( int n ) { int soma = 0; for (i=1; i<=n; i++) { soma = soma + i; } return soma; } int somatorio( int n ) { return n*(n+1)/2; }
O(n)
O(1)
- 121 -
- Anlise Assinttica Multivarivel
Anlise Assinttica Multivarivel Em muitos casos, a quantidade de dados a serem processados no depende apenas de 1 nico parmetro. Nestes casos, necessria a construo de uma funo com duas ou mais variveis. O custo do algoritmo pode ser analisado em relao a cada varivel separadamente.
- 122 -
Limites Assintticos Multivariveis
O(g(n,m)) = { f(n,m) : existem constantes positivas c, n0 e m0 tais que 0 f(n,m) cg(n,m) para todo n n0 e m m0 }
(g(n,m)) = { f(n,m) : existem constantes positivas c, n0 e m0 tais que 0 cg(n,m) f(n,m) para todo n n0 e m m0 }
(g(n,m)) = { f(n,m) : existem constantes positivas c, n0 e m0 tais que 0 c1g(n,m) f(n,m) c2g(n,m) p/ todo n n0 e m m0 } O(g(n,m)) = { f(n,m) : para todo c > 0, existem n0 > 0 e m0 > 0 tais que 0 f(n,m) cg(n,m) para todo n n0 e m m0 }
(g(n,m)) = { f(n,m) : para todo c > 0, existem n0 > 0 e m0 > 0 tais que 0 cg(n,m) f(n,m) para todo n n0 e m m0 }
Estas definies podem ser estendidas para 3 ou mais variveis.
- 123 -
Exemplo: Multiplicao de Matrizes (caso geral)
multiplicar matriz mxn por matriz nxp para linha i = 1,2,3,,m para coluna j = 1,2,3,,p xij 0 para elementos k = 1,2,3,,n O(n) xij xij + aik * bkj O(1) fim elementos fim colunas fim linhas
O(m) O(p)
O(m) . O(p) . O(n) . O(1) = O(mpn)

- 124 -
Exemplo: Simulao de circuito eltrico Parmetros:
p = nmero de passos de integrao (pontos no grfico) n = nmero de ns (conexes) do circuito m = nmero de ramos do circuito k = nmero de iteraes de Newton-Raphson (resoluo de equaes no-lineares por aproximao)
- 125 -
Simulao de um circuito eltrico (simplificada): Para cada passo de integrao O(p) Para cada iterao NR O(k) Calcular matriz de admitncia nodal O(m2n) Encontrar tenses nodais O(n3) Calcular erro de aproximao O(n)
Fim das iteraes NR Fim dos passos de integrao Complexidade Total
O(p).O(k).O(n3+m2n) = O(pkn3+pkm2n)
- 126 -
Complexidade Total: O( pkn3 + pkm2n )
O algoritmo tem taxa de crescimento linear em relao a p e k, quadrtica em relao a m e cbica em relao a n . Se dobrarmos o nmero de passos de integrao p, o tempo de processamento dobra. Se dobrarmos o nmero de iteraes k, o tempo de processamento dobra. Para um circuito muito grande, se dobrarmos o nmero de ramos m, o tempo de processamento aumenta 4 vezes. Para um circuito muito grande, se dobrarmos o nmero de vrtices n, o tempo de processamento aumenta 8 vezes. - 127 -

Aula05 AnaliseAssintotica

Caricato da

Informazioni sul documento

Titolo originale

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

Aula05 AnaliseAssintotica

Caricato da

Copyright:

Formati disponibili

5.

1.000.000 2.000.005.000.008 2.000.000.000.000

Mas ... como comparar taxas de crescimento ?

tais que 0 cg(n) f(n) para todo n n0 } Se f(n)

tais que 0 cg(n) f(n) para todo n n0 }

Algumas propriedades so muito semelhantes . . . - 42 -

f(n) f(n) f(n) f(n) f(n) = f(n)

No vlida para o() e () .

f(n) g(n) f(n) < g(n)

Exemplo: n1+sen(n) no o(g(n)) nem (g(n)) e nem (g(n)).

f(n) O(g(n)) e f(n)

O(n) . O(n) . O(1) = O(n2)

para elementos k = 1,2,3,,n O(n)

O(n) . O(n) . O(n) . O(1) = O(n3)

Experimento 5.1 Experimento 5.2

O algoritmo de soma de matrizes quadradas (n2). O algoritmo de multiplicao de matrizes (n3).

Pesquisa sem sucesso:

kmax = log2 n + 1 = O(log n)

O(log n) iteraes Custo O(1) por iterao

O algoritmo tem limite superior

O(log n) O(1) = O(log n)

1.000.000.000.000 500.000.000.000 - 101 -

Somar matrizes quadradas

Multiplicar matrizes quadradas

5. Anlise Assinttica - Eficincia tima

5. Anlise Assinttica - Eficincia tima

5. Anlise Assinttica - Eficincia tima

5. Anlise Assinttica - Eficincia tima

5. Anlise Assinttica - Eficincia tima

O(n) O(n) O(1) O(n2)

O(n) O(log n) O(1) O(n.log n)

Estas definies podem ser estendidas para 3 ou mais variveis.

O(m) . O(p) . O(n) . O(1) = O(mpn)

Potrebbero piacerti anche