Download - aed1

Algoritmos e Estruturas de Dados 2010/2011 Luis Antunes

Anlise de Algoritmos

Fac. Cincias Univ. Lisboa Luis Antunes Algoritmos e Estruturas de Dados 2010-2011

Eficincia de Algoritmos

! Em Java no fcil medir a quantidade de tempo que um programa leva a executar. ! Primeiro carrefado o JVM (Java Virtual Machine) ! Depois o ficheiro .class, depois outros ficheiros .class ! E finalmente o programa executa ! Se for num IDE (integrated development environment)

ainda pode ser anteriormente compilado o ficheiro.

! Logo, tenta-se aproximar o efeito das mudanas no nmero de itens de dados (n) que o algoritmo processa.

! Comparamos 2 algoritmos comparando as taxas de crescimento (com n).

Fac. Cincias Univ. Lisboa

Luis Antunes Algoritmos e Estruturas de Dados 2010-2011

Eficincia

! Muitos algoritmos bvios so ineficientes ! Mas podem servir para instncias simples dos problemas

! Outros algoritmos tm uma taxa de crescimento to grande que, mesmo com os modernos computadores, cada vez mais rpidos e com memrias maiores, no conseguem executar.



O crescimento das funes

! Dada a funo f(n), como cresce se aumentarmos n?



0

1000

2000

3000

4000

5000

6000

7000

8000

9000

1 2 3 4 5 6 7 8 9

2nn 2^n 3^e n^

2*n n^2 n^3 e^n1 2 1 1 2,72 4 4 8 7,43 6 9 27 20,14 8 16 64 54,65 10 25 125 148,46 12 36 216 403,47 14 49 343 1096,68 16 64 512 2981,09 18 81 729 8103,1

f(n)n

O crescimento das funes

! Este assunto relevante para grandes problemas ! Mesmo maus algoritmos podem servir em pequenas tarefas... ! Vamos ignorar detalhes de implementao e focar apenas os

pontos relevantes do algoritmo em questo

! Primeiro, quantificamos o crescimento de funes em relao a outras funes. ! Para depois poder comparar o tempo (memria) que demora

(ocupa) um dado algoritmo a resolver problemas progressivamente maiores, com o crescimento de certas funes (por exemplo f(n) = n, f(n) = n3, f(n) = en...)



Exemplo: procura num array


Luis Antunes Introduo Programao 2010-2011

! Se o target no estiver presente, o ciclo for executado x.length vezes

! Se o target estiver presente, pode estar em qualquer stio.

! Assim, em mdia o ciclo ser executado x.length/2 vezes

! O tempo de execuo proporcional a x.length

Exemplo: ver se h elementos em comum

! O corpo do ciclo executado x.length vezes.

! Mas invoca o search, que executado y.length vezes para cada uma das x.length vezes

! A execuo total proporcional ao produto de y.length por x.length



Exemplo: ver se cada elemento nico

! Se todos os elementos forem nicos, o ciclo i executado x.length vezes

! Dentro deste, o ciclo j executado tambm x.length vezes

! Logo o corpo do ciclo interior executado (x.length)2 vezes.



Verso mais eficiente

! Na primeira vez no ciclo j, h x.length-1 vezes

! Na segunda vez x-.length-2 vezes

! Na ltima vez, apenas 1

! O nmero total n x (n-1)/2 (com n = x.length vezes)



Notao O ( grande)

! Definio: ! Sejam duas funes f, g: .

A funo g domina assimptoticamente f, escrevendo-se f O(g), sse, k C n : n>k |f(n)| C.|g(n)|

! Ou seja, existe um par de constantes naturais k e C, tal que, a partir de um dado argumento n>k, a funo g sempre maior que f. ! Isto determina um limite superior ao crescimento da funo f.

! De notar que O(g) representa um conjunto de funes que so limitadas superiormente por g. O(g) diz-se uma classe de complexidade. ! Dizer f O(g) ou f de ordem g dizer f O(g). ! f O(g) O(f) O(g)



Notao O Exemplos



1000000 O(1) 4.m 1 O(m) 10/n O(1/n) 5.x2 O(x3) 5.x2 O(x2) 5.x2 no O(x) 500.n4 n2 O(n4) 500.n4 + n2 O(n4) n2.log10(n) O(n2.log(n)) 45.2n O(en) e 2.71828... 6n no O(5n)

Notao O ! Para comparar algoritmos da mesma classe de complexidade

pode ser til apresentar um maior detalhe da funo de crescimento. Por exemplo, f(n) = n2 + n.log(n) cresce mais depressa que g(n) = n2 + n, apesar de f e g serem O(n2)

! A constante do factor de maior crescimento tambm e til nessa comparao. Por exemplo, a funo f(n) = n2/10 cresce mais devagar que g(n) = 10.n2

! Em casos que na prtica ocorrem raramente, as constantes das funes podem ser relevantes na comparao de algoritmos de classes distintas. Por exemplo, a funo f(n) = 2n/100000 menor que a funo g(n) = n100000 para um extenso conjunto da valores de n, apesar de g ser O(f) e f no ser O(g)



Algoritmos e Estruturas de Dados DI - FCUL

Algumas Propriedades

Seja a funo F de ordem O(f) e G de ordem O(g)

F de ordem O(F) Exemplo: 5.n2 + 4.n 300 O( 5.n2 + 4.n 300 )

c.F, com c uma constante, de ordem O(f) Exemplo: O( 5000.n2 ) = O( n2 )

F + G de ordem O( f + g ) Exemplo: O( n2 ) + O( n ) = O( n2 + n ) = O( n2 )

F G de ordem O(f g) Exemplo: O( n2 ) O( n3 . log n) = O( n5 . log n)

se F O(G) ento O( f + g ) = O( g )


Classes de Complexidade

Algumas classes de complexidade importantes (e progressivamente mais abrangentes):

Constante, O(1) Logartmica, O(log n) Linear, O(n) Pseudo-linear, O(n. log n) Quadrtica, O(n2) Polinomial, p1 O(np) Exponencial, p>1 O(pn) Factorial, O(n!) (n/e)n. 2n

Comparao de funes


Luis Antunes Introduo Programao 2010-2011


Tempo vs. Espao

A complexidade temporal determina o nmero aproximado de operaes necessrias para resolver um problema de dimenso n.

A complexidade espacial determina a memria aproximadamente necessria para resolver um problema de dimenso n.

Estas complexidades podem ser analisadas no cenrio: do melhor caso possvel (best-case) do pior caso possvel (worst-case) do caso mdio (average-case), para o qual se considera uma distribuio probabilstica associada aos dados de entrada.

Quando nada se sabe, assume-se uma distribuio uniforme.


Anlise de Programas A complexidade temporal de um programa pode ser determinada analisando a sua estrutura. Como uma linguagem de programao possui uma sintaxe e uma semntica bem definidas, a tarefa facilitada.

Considerase o pior caso, i.e., escolhese sempre a opo que implique no nmero mximo de instrues. Procedese da mesma forma para o clculo da complexidade espacial. Existe um conjunto de comandos cuja complexidade temporal constante, i.e., pertencem classe O(1):

Declaraes Atribuies Acessos aos mtodos Uso das operaes aritmticas, lgicas e relacionais dos tipos de dados primitivos


Anlise de Programas Em relao aos restantes comandos, considere a guarda G O(fG), os comandos A O(fA), B O(fB) e C O(fC) e N como o nmero de iteraes mximo de cada ciclo:

A; B; O( fA + fB ) if (G) A else B; O( fG + fA + fB ) while (G) A; O( N . ( fG + fA ) ) do A while (G); O( N . ( fG + fA ) ) for (B;G;C) A; O( fB + N . ( fG + fA + fC ) )


Um exemplo

Qual a complexidade do seguinte cdigo?

1 int x=0; 2 for(int i=0; i O(1) um clculo de expresso e uma atribuio 3-4 -> O(1+n(1+1+1)) = O(1+3n) = O(n) um ciclo for 2-4 -> O(1+n(1+1+n)) = O(1+2n+n2) = O(n2) um ciclo for 1-4 -> O(1+n2) = O(n2) o cdigo a sequncia de duas instrues

principais


Um exemplo mais complicado...

Seja f(v) o nmero de instrues executadas por este mtodo. Qual a sua complexidade temporal?

void slowSort( int[] v ) { for(int i=0; i


Outro exemplo

Dado o seguinte cdigo, qual a sua complexidade temporal?

//@ requires domain.length == images.length boolean isInjective(int[] domain, int[] images) { slowSort( images ); for(int i=1; i

Download - aed1

Top Related