• Nenhum resultado encontrado

Análise de Algoritmos

N/A
N/A
Info
Descarregar agora
Protected

Academic year: 2022

Share "Análise de Algoritmos"

Copied!
62
0
0

Carregando.... (Ver texto completo agora)

Descarregar agora ( 62 páginas )

Texto

(1)
(2)

• O que significa?

▫ Prever os recursos que o algoritmo necessitará

▫ Tempo, memória, largura de banda, hardware,...

• O tempo

▫ Número de operações primitivas ou etapas executadas

▫ Depende do tamanho da entrada

• Formas de analisar

▫ Contar todas as instruções – custo exato

▫ Contar as instruções mais importantes (mais executadas,

mais caras) – custo aproximado

(3)

INSERTION-SORT(A, n) 1: for j  2 to n do 2: chave  A[j];

3: i  j – 1;

4: while i > 0 and A[i] > chave do 5: A[i+1]  A[i];

6: i  i – 1;

7: end while

8: A[i+1]  chave;

9: end for

Qual instrução você escolheria para contar? Por quê?

(4)

INSERTION-SORT(A, n) 1: for j  2 to n do 2: chave  A[j];

3: i  j – 1;

4: while i > 0 and A[i] > chave do 5: A[i+1]  A[i];

6: i  i – 1;

7: end while

8: A[i+1]  chave;

9: end for

Qual instrução você escolheria para contar? Por quê?

(5)

INSERTION-SORT(A, n) 1: for j  2 to n do 2: chave  A[j];

3: i  j – 1;

4: while i > 0 and A[i] > chave do 5: A[i+1]  A[i];

6: i  i – 1;

7: end while

8: A[i+1]  chave;

9: end for

(6)

valor de j # de comparações

Melhor caso Pior caso

2 1 1

3 1 2

4 1 3

5 1 4

... ... ...

n 1 n-1

1

1

2

 

n

n

j

   

2 1 1

2

 

 

n j n

n

j

Melhor caso: Pior caso:

(7)

INSERTION-SORT(A, n) 1: for j  2 to n do 2: chave  A[j];

3: i  j – 1;

4: while i > 0 and A[i] > chave do 5: A[i+1]  A[i];

6: i  i – 1;

7: end while

8: A[i+1]  chave;

9: end for

c 1

1   1    1   11

)

( 7

2 6 2

5 2

4 3

2

1           

   

n c t

c t

c t

c n

c n

c n c n

T

n

j

j n

j

j n

j j

c 3

c 4

c 5

c 6

c 7

n

 1 n

 1

nn

j t j 2

n  

j t j

2 ( 1 )

 1

n

c 2

(8)

INSERTION-SORT(A, n) 1: for j  2 to n do 2: chave  A[j];

3: i  j – 1;

4: while i > 0 and A[i] > chave do 5: A[i+1]  A[i];

6: i  i – 1;

7: end while

8: A[i+1]  chave;

9: end for

 1 t j

Melhor caso

1   1( 1 )1

)

( nc 1 nc 2 n   c 3 n   c 4 n   c 7 n

T

(9)

INSERTION-SORT(A, n) 1: for j  2 to n do 2: chave  A[j];

3: i  j – 1;

4: while i > 0 and A[i] > chave do 5: A[i+1]  A[i];

6: i  i – 1;

7: end while

8: A[i+1]  chave;

9: end for

j t j

Pior caso

     1

2 ) 1 (

2 ) 1 1 (

2 ) 1 1 (

1 )

( 1 2 3 4   5   6   7

 

  

n n c n

n c c n

n c n

n c n

c n c n

T

(10)

• Para simplificar a análise

▫ Utilizamos apenas a ordem de crescimento (componente mais caro da função de custo)

▫ Constantes e elementos de ordem inferior são descartados

▫ Para o insertion-sort a ordem de crescimento é

1( )

1

2

n n

n

j

 

 

) 2 (

2 2

1 1 2

2

2

n n n

n j n

n

j

 

 

 

 

 

Melhor caso:

Pior caso:

(11)
(12)

• O insertion-sort utiliza uma abordagem incremental

▫ O sub-arranjo A[1..j-1] já foi ordenado

▫ Inserimos o elemento A[j] na posição certa

• Divisão e conquista

▫ Abordagem complementar

▫ Normalmente fáceis de analisar

▫ Normalmente custo inferior a abordagens incrementais

(13)

• Muitos algoritmos são naturalmente recursivos

▫ Para resolver o problema, chamam a si mesmos resolvendo subproblemas relacionados

▫ Abordagem de dividir e conquistar

• Você consegue lembrar de algum algoritmo recursivo para um

problema específico?

(14)

• Dividir

▫ Dividir o problema em subproblemas semelhantes

• Conquistar

▫ Resolver os subproblemas recursivamente

▫ Problemas pequenos o suficiente são resolvidos diretamente

• Combinar

▫ Juntar e combinar as soluções do subproblema

▫ Obter uma solução para o problema original

(15)

• Merge-sort (ordenação por intercalação)

▫ Dividir: Divide a seqüência de n elementos em duas partes, cada uma com (n / 2) elementos

▫ Conquistar: Ordena as duas partes usando o merge-sort recursivamente

▫ Combinar: Faz a intercalação das duas seqüências ordenadas

• A recursão pára quando a seqüência é de tamanho 1,

pois não há nada a ser feito

(16)

MERGE(A, p, q, r)

1: L  LEFT (A, p, q, r);

2: R  RIGHT(A, p, q, r);

3: i  1;

4: j  1;

5: for k  p to r do

6: if L[i] <= R[j] then 7: A[k]  L[i];

8: i  i + 1;

9: else

10: A[k]  R[j];

11: j  j + 1;

12: end if 13: end for

LEFT(A, p, q, r) 1: fim  q–p+1;

2: for i  1 to fim do 3: L[i]  A[p+i-1];

4: end for

5: L[fim+1]  INF;

6: return L;

RIGHT(A, p, q, r) 1: fim  r-q;

2: for i  1 to fim do 3: R[i]  A[q+i-1];

4: end for

5: R[fim+1]  INF;

6: return R;

(17)

p q r 8 9 10 11 12 13 14 15 16

A ... 2 4 5 7 1 2 3 6 ...

k

1 2 3 4 5 1 2 3 4 5

L 2 4 5 7  R 1 2 3 6 

i j

MERGE(A, p, q, r)

1: L  LEFT(A, p, q, r);

2: R  RIGHT(A, p, q, r);

3: i  1;

4: j  1;

5: for k  p to r do

6: if L[i] <= R[j] then 7: A[k]  L[i];

8: i  i + 1;

9: else

10: A[k]  R[j];

11: j  j + 1;

12: end if

13: end for

(18)

MERGE(A, p, q, r)

1: L  LEFT(A, p, q, r);

2: R  RIGHT(A, p, q, r);

3: i  1;

4: j  1;

5: for k  p to r do

6: if L[i] <= R[j] then 7: A[k]  L[i];

8: i  i + 1;

9: else

10: A[k]  R[j];

11: j  j + 1;

12: end if 13: end for

p q r

8 9 10 11 12 13 14 15 16

A ... 1 4 5 7 1 2 3 6 ...

k k k k k k k k

1 2 3 4 5 1 2 3 4 5

L 2 4 5 7  R 1 2 3 6 

i j j j j j j j j j

(19)

MERGE(A, p, q, r)

1: L  LEFT(A, p, q, r);

2: R  RIGHT(A, p, q, r);

3: i  1;

4: j  1;

5: for k  p to r do

6: if L[i] <= R[j] then 7: A[k]  L[i];

8: i  i + 1;

9: else

10: A[k]  R[j];

11: j  j + 1;

12: end if 13: end for

p q r

8 9 10 11 12 13 14 15 16

A ... 1 2 5 7 1 2 3 6 ...

k k k k k k k k

1 2 3 4 5 1 2 3 4 5

L 2 4 5 7  R 1 2 3 6 

i i i i i j j j j j

(20)

MERGE(A, p, q, r)

1: L  LEFT(A, p, q, r);

2: R  RIGHT(A, p, q, r);

3: i  1;

4: j  1;

5: for k  p to r do

6: if L[i] <= R[j] then 7: A[k]  L[i];

8: i  i + 1;

9: else

10: A[k]  R[j];

11: j  j + 1;

12: end if 13: end for

p q r

8 9 10 11 12 13 14 15 16

A ... 1 2 2 7 1 2 3 6 ...

k k k k k k k k

1 2 3 4 5 1 2 3 4 5

L 2 4 5 7  R 1 2 3 6 

i i i i i j j j j j

(21)

MERGE(A, p, q, r)

1: L  LEFT(A, p, q, r);

2: R  RIGHT(A, p, q, r);

3: i  1;

4: j  1;

5: for k  p to r do

6: if L[i] <= R[j] then 7: A[k]  L[i];

8: i  i + 1;

9: else

10: A[k]  R[j];

11: j  j + 1;

12: end if 13: end for

p q r

8 9 10 11 12 13 14 15 16

A ... 1 2 2 3 1 2 3 6 ...

k k k k k k k k

1 2 3 4 5 1 2 3 4 5

L 2 4 5 7  R 1 2 3 6 

i i i i i j j j j j

(22)

MERGE(A, p, q, r)

1: L  LEFT(A, p, q, r);

2: R  RIGHT(A, p, q, r);

3: i  1;

4: j  1;

5: for k  p to r do

6: if L[i] <= R[j] then 7: A[k]  L[i];

8: i  i + 1;

9: else

10: A[k]  R[j];

11: j  j + 1;

12: end if 13: end for

p q r

8 9 10 11 12 13 14 15 16

A ... 1 2 2 3 4 2 3 6 ...

k k k k k k k k

1 2 3 4 5 1 2 3 4 5

L 2 4 5 7  R 1 2 3 6 

i i i i i j j j j j

(23)

MERGE(A, p, q, r)

1: L  LEFT(A, p, q, r);

2: R  RIGHT(A, p, q, r);

3: i  1;

4: j  1;

5: for k  p to r do

6: if L[i] <= R[j] then 7: A[k]  L[i];

8: i  i + 1;

9: else

10: A[k]  R[j];

11: j  j + 1;

12: end if 13: end for

p q r

8 9 10 11 12 13 14 15 16

A ... 1 2 2 3 4 5 3 6 ...

k k k k k k k k

1 2 3 4 5 1 2 3 4 5

L 2 4 5 7  R 1 2 3 6 

i i i i i j j j j j

(24)

MERGE(A, p, q, r)

1: L  LEFT(A, p, q, r);

2: R  RIGHT(A, p, q, r);

3: i  1;

4: j  1;

5: for k  p to r do

6: if L[i] <= R[j] then 7: A[k]  L[i];

8: i  i + 1;

9: else

10: A[k]  R[j];

11: j  j + 1;

12: end if 13: end for

p q r

8 9 10 11 12 13 14 15 16

A ... 1 2 2 3 4 5 6 6 ...

k k k k k k k k

1 2 3 4 5 1 2 3 4 5

L 2 4 5 7  R 1 2 3 6 

i i i i i j j j j j

(25)

MERGE(A, p, q, r)

1: L  LEFT(A, p, q, r);

2: R  RIGHT(A, p, q, r);

3: i  1;

4: j  1;

5: for k  p to r do

6: if L[i] <= R[j] then 7: A[k]  L[i];

8: i  i + 1;

9: else

10: A[k]  R[j];

11: j  j + 1;

12: end if 13: end for

p q r

8 9 10 11 12 13 14 15 16

A ... 1 2 2 3 4 5 6 7 ...

k k k k k k k k k

1 2 3 4 5 1 2 3 4 5

L 2 4 5 7  R 1 2 3 6 

i i i i i j j j j j

(26)

MERGE-SORT(A, p, r) 1: if p < r then

2: q  (p+r)/2; // inteiro 3: MERGE-SORT(A,p,q);

4: MERGE-SORT(A,q+1,r);

5: MERGE(A,p,q,r);

6: end if

5 2 4 7 1 3 2 6

(27)

MERGE-SORT(A, p, r) 1: if p < r then

2: q  (p+r)/2; // inteiro 3: MERGE-SORT(A,p,q);

4: MERGE-SORT(A,q+1,r);

5: MERGE(A,p,q,r);

6: end if

5 2 4 7 1 3 2 6

5 2 4 7

(28)

MERGE-SORT(A, p, r) 1: if p < r then

2: q  (p+r)/2; // inteiro 3: MERGE-SORT(A,p,q);

4: MERGE-SORT(A,q+1,r);

5: MERGE(A,p,q,r);

6: end if

5 2 4 7 1 3 2 6

5 2 4 7

5 2

(29)

MERGE-SORT(A, p, r) 1: if p < r then

2: q  (p+r)/2; // inteiro 3: MERGE-SORT(A,p,q);

4: MERGE-SORT(A,q+1,r);

5: MERGE(A,p,q,r);

6: end if

5 2 4 7 1 3 2 6

5 2 4 7

5 2

5

(30)

MERGE-SORT(A, p, r) 1: if p < r then

2: q  (p+r)/2; // inteiro 3: MERGE-SORT(A,p,q);

4: MERGE-SORT(A,q+1,r);

5: MERGE(A,p,q,r);

6: end if

5 2 4 7 1 3 2 6

5 2 4 7

5 2

5

(31)

MERGE-SORT(A, p, r) 1: if p < r then

2: q  (p+r)/2; // inteiro 3: MERGE-SORT(A,p,q);

4: MERGE-SORT(A,q+1,r);

5: MERGE(A,p,q,r);

6: end if

5 2 4 7 1 3 2 6

5 2 4 7

5 2

5 2

(32)

MERGE-SORT(A, p, r) 1: if p < r then

2: q  (p+r)/2; // inteiro 3: MERGE-SORT(A,p,q);

4: MERGE-SORT(A,q+1,r);

5: MERGE(A,p,q,r);

6: end if

5 2 4 7 1 3 2 6

5 2 4 7

5 2

5 2

(33)

MERGE-SORT(A, p, r) 1: if p < r then

2: q  (p+r)/2; // inteiro 3: MERGE-SORT(A,p,q);

4: MERGE-SORT(A,q+1,r);

5: MERGE(A,p,q,r);

6: end if

5 2 4 7 1 3 2 6

5 2 4 7

2 5

5 2

(34)

MERGE-SORT(A, p, r) 1: if p < r then

2: q  (p+r)/2; // inteiro 3: MERGE-SORT(A,p,q);

4: MERGE-SORT(A,q+1,r);

5: MERGE(A,p,q,r);

6: end if

5 2 4 7 1 3 2 6

5 2 4 7

2 5 4 7

5 2

(35)

MERGE-SORT(A, p, r) 1: if p < r then

2: q  (p+r)/2; // inteiro 3: MERGE-SORT(A,p,q);

4: MERGE-SORT(A,q+1,r);

5: MERGE(A,p,q,r);

6: end if

5 2 4 7 1 3 2 6

5 2 4 7

2 5 4 7

5 2 4

(36)

MERGE-SORT(A, p, r) 1: if p < r then

2: q  (p+r)/2; // inteiro 3: MERGE-SORT(A,p,q);

4: MERGE-SORT(A,q+1,r);

5: MERGE(A,p,q,r);

6: end if

5 2 4 7 1 3 2 6

5 2 4 7

2 5 4 7

5 2 4

(37)

MERGE-SORT(A, p, r) 1: if p < r then

2: q  (p+r)/2; // inteiro 3: MERGE-SORT(A,p,q);

4: MERGE-SORT(A,q+1,r);

5: MERGE(A,p,q,r);

6: end if

5 2 4 7 1 3 2 6

5 2 4 7

2 5 4 7

5 2 4 7

(38)

MERGE-SORT(A, p, r) 1: if p < r then

2: q  (p+r)/2; // inteiro 3: MERGE-SORT(A,p,q);

4: MERGE-SORT(A,q+1,r);

5: MERGE(A,p,q,r);

6: end if

5 2 4 7 1 3 2 6

5 2 4 7

2 5 4 7

5 2 4 7

(39)

MERGE-SORT(A, p, r) 1: if p < r then

2: q  (p+r)/2; // inteiro 3: MERGE-SORT(A,p,q);

4: MERGE-SORT(A,q+1,r);

5: MERGE(A,p,q,r);

6: end if

5 2 4 7 1 3 2 6

5 2 4 7

2 5 4 7

5 2 4 7

(40)

MERGE-SORT(A, p, r) 1: if p < r then

2: q  (p+r)/2; // inteiro 3: MERGE-SORT(A,p,q);

4: MERGE-SORT(A,q+1,r);

5: MERGE(A,p,q,r);

6: end if

5 2 4 7 1 3 2 6

2 4 5 7

2 5 4 7

5 2 4 7

(41)

MERGE-SORT(A, p, r) 1: if p < r then

2: q  (p+r)/2; // inteiro 3: MERGE-SORT(A,p,q);

4: MERGE-SORT(A,q+1,r);

5: MERGE(A,p,q,r);

6: end if

5 2 4 7 1 3 2 6

2 4 5 7 1 3 2 6

2 5 4 7

5 2 4 7

(42)

MERGE-SORT(A, p, r) 1: if p < r then

2: q  (p+r)/2; // inteiro 3: MERGE-SORT(A,p,q);

4: MERGE-SORT(A,q+1,r);

5: MERGE(A,p,q,r);

6: end if

5 2 4 7 1 3 2 6

2 4 5 7 1 3 2 6

2 5 4 7 1 3

5 2 4 7

(43)

MERGE-SORT(A, p, r) 1: if p < r then

2: q  (p+r)/2; // inteiro 3: MERGE-SORT(A,p,q);

4: MERGE-SORT(A,q+1,r);

5: MERGE(A,p,q,r);

6: end if

5 2 4 7 1 3 2 6

2 4 5 7 1 3 2 6

2 5 4 7 1 3

5 2 4 7 1

(44)

MERGE-SORT(A, p, r) 1: if p < r then

2: q  (p+r)/2; // inteiro 3: MERGE-SORT(A,p,q);

4: MERGE-SORT(A,q+1,r);

5: MERGE(A,p,q,r);

6: end if

5 2 4 7 1 3 2 6

2 4 5 7 1 3 2 6

2 5 4 7 1 3

5 2 4 7 1

(45)

MERGE-SORT(A, p, r) 1: if p < r then

2: q  (p+r)/2; // inteiro 3: MERGE-SORT(A,p,q);

4: MERGE-SORT(A,q+1,r);

5: MERGE(A,p,q,r);

6: end if

5 2 4 7 1 3 2 6

2 4 5 7 1 3 2 6

2 5 4 7 1 3

5 2 4 7 1 3

(46)

MERGE-SORT(A, p, r) 1: if p < r then

2: q  (p+r)/2; // inteiro 3: MERGE-SORT(A,p,q);

4: MERGE-SORT(A,q+1,r);

5: MERGE(A,p,q,r);

6: end if

5 2 4 7 1 3 2 6

2 4 5 7 1 3 2 6

2 5 4 7 1 3

5 2 4 7 1 3

(47)

MERGE-SORT(A, p, r) 1: if p < r then

2: q  (p+r)/2; // inteiro 3: MERGE-SORT(A,p,q);

4: MERGE-SORT(A,q+1,r);

5: MERGE(A,p,q,r);

6: end if

5 2 4 7 1 3 2 6

2 4 5 7 1 3 2 6

2 5 4 7 1 3

5 2 4 7 1 3

(48)

MERGE-SORT(A, p, r) 1: if p < r then

2: q  (p+r)/2; // inteiro 3: MERGE-SORT(A,p,q);

4: MERGE-SORT(A,q+1,r);

5: MERGE(A,p,q,r);

6: end if

5 2 4 7 1 3 2 6

2 4 5 7 1 3 2 6

2 5 4 7 1 3 2 6

5 2 4 7 1 3

(49)

MERGE-SORT(A, p, r) 1: if p < r then

2: q  (p+r)/2; // inteiro 3: MERGE-SORT(A,p,q);

4: MERGE-SORT(A,q+1,r);

5: MERGE(A,p,q,r);

6: end if

5 2 4 7 1 3 2 6

2 4 5 7 1 3 2 6

2 5 4 7 1 3 2 6

5 2 4 7 1 3 2

(50)

MERGE-SORT(A, p, r) 1: if p < r then

2: q  (p+r)/2; // inteiro 3: MERGE-SORT(A,p,q);

4: MERGE-SORT(A,q+1,r);

5: MERGE(A,p,q,r);

6: end if

5 2 4 7 1 3 2 6

2 4 5 7 1 3 2 6

2 5 4 7 1 3 2 6

5 2 4 7 1 3 2

(51)

MERGE-SORT(A, p, r) 1: if p < r then

2: q  (p+r)/2; // inteiro 3: MERGE-SORT(A,p,q);

4: MERGE-SORT(A,q+1,r);

5: MERGE(A,p,q,r);

6: end if

5 2 4 7 1 3 2 6

2 4 5 7 1 3 2 6

2 5 4 7 1 3 2 6

5 2 4 7 1 3 2 6

(52)

MERGE-SORT(A, p, r) 1: if p < r then

2: q  (p+r)/2; // inteiro 3: MERGE-SORT(A,p,q);

4: MERGE-SORT(A,q+1,r);

5: MERGE(A,p,q,r);

6: end if

5 2 4 7 1 3 2 6

2 4 5 7 1 3 2 6

2 5 4 7 1 3 2 6

5 2 4 7 1 3 2 6

(53)

MERGE-SORT(A, p, r) 1: if p < r then

2: q  (p+r)/2; // inteiro 3: MERGE-SORT(A,p,q);

4: MERGE-SORT(A,q+1,r);

5: MERGE(A,p,q,r);

6: end if

5 2 4 7 1 3 2 6

2 4 5 7 1 3 2 6

2 5 4 7 1 3 2 6

5 2 4 7 1 3 2 6

(54)

MERGE-SORT(A, p, r) 1: if p < r then

2: q  (p+r)/2; // inteiro 3: MERGE-SORT(A,p,q);

4: MERGE-SORT(A,q+1,r);

5: MERGE(A,p,q,r);

6: end if

5 2 4 7 1 3 2 6

2 4 5 7 1 2 3 6

2 5 4 7 1 3 2 6

5 2 4 7 1 3 2 6

(55)

MERGE-SORT(A, p, r) 1: if p < r then

2: q  (p+r)/2; // inteiro 3: MERGE-SORT(A,p,q);

4: MERGE-SORT(A,q+1,r);

5: MERGE(A,p,q,r);

6: end if

1 2 2 3 4 5 6 7

2 4 5 7 1 2 3 6

2 5 4 7 1 3 2 6

5 2 4 7 1 3 2 6

(56)

MERGE-SORT(A, p, r) 1: if p < r then

2: q  (p+r)/2; // inteiro 3: MERGE-SORT(A,p,q);

4: MERGE-SORT(A,q+1,r);

5: MERGE(A,p,q,r);

6: end if

(57)

MERGE(A, p, q, r)

1: L  LEFT (A, p, q, r);

2: R  RIGHT(A, p, q, r);

3: i  1;

4: j  1;

5: for k  p to r do

6: if L[i] <= R[j] then 7: A[k]  L[i];

8: i  i + 1;

9: else

10: A[k]  R[j];

11: j  j + 1;

12: end if 13: end for

LEFT(A, p, q, r) 1: fim  q–p+1;

2: for i  1 to fim do 3: L[i]  A[p+i-1];

4: end for

5: L[fim+1]  INF;

6: return L;

RIGHT(A, p, q, r) 1: fim  r-q;

2: for i  1 to fim do 3: R[i]  A[p+i-1];

4: end for

5: R[fim+1]  INF;

6: return R;

(58)

LEFT(A, p, q, r) 1: fim  q–p+1;

2: for i  1 to fim do 3: L[i]  A[p+i-1];

4: end for

5: L[fim+1]  INF;

6: return L;

RIGHT(A, p, q, r) 1: fim  r-q;

2: for i  1 to fim do 3: R[i]  A[p+i-1];

4: end for

5: R[fim+1]  INF;

6: return R;

2 )

( n n T L

2 )

( n n

T R

(59)

MERGE(A, p, q, r)

1: L  LEFT (A, p, q, r);

2: R  RIGHT(A, p, q, r);

3: i  1;

4: j  1;

5: for k  p to r do

6: if L[i] <= R[j] then 7: A[k]  L[i];

8: i  i + 1;

9: else

10: A[k]  R[j];

11: j  j + 1;

12: end if 13: end for

2 n

2 n

n

) ( 2

2 2

)

( n n n n n n

T M      

(60)

MERGE-SORT(A, p, r) 1: if p < r then

2: q  (p+r)/2; // inteiro 3: MERGE-SORT(A,p,q);

4: MERGE-SORT(A,q+1,r);

5: MERGE(A,p,q,r);

6: end if

  

 

 

1 se

, 2

2

1 se

) ,

(

2 1

n n

c n

T

n n c

T

  

 

 

1 se

, 2

2

1 se

, ) 1

( T n n n

n n

T

(61)

• Para facilitar a análise, suponha que n 2 k

  n n

T n

T ( )  2 2 

  

 

 

1 se

, 2

2

1 se

, ) 1

( T n n n

n n T

2 T   n 4 n 2n 4 T   n 4 2 n

2    

2 T   n 8 n 42 n 8 T   n 8 3 n

4    

 

2 T n 16 n 83 n 16 Tn 164 n

8    

  n an

T n

T ( )  2 a 2 a

(62)

• Note que quando temos ak

  n an

T n

T ( )  2 a 2 a

  kn

T k k

k

 2 2 2

  kn kn

T n

T ( )  2 k 1   2 k

como n  2 k

então k  log 2 n

kn n

T ( )  2 k

n

n n

2

log log

2

2

n n n

n

T ( )  log 2

n n

n

T ( )   lg

Referências

Descarregar agora ( PDF - 62 páginas - 2.01 MB )

Documentos relacionados

Dissertação

Esse tipo de análise só estaria correta nos casos onde o deslocamento do vídeo ocorresse da esquerda para a direita, caso o deslocamento ocorresse no sentido inverso,

SABER POPULAR: (RE)CONHECENDO ALGUMAS PLANTAS NATIVAS COM POTENCIAL FITOTERÁPICO NO CERRADO EM IPAMERI (GO)

O objetivo do curso foi oportunizar aos participantes, um contato direto com as plantas nativas do Cerrado para identificação de espécies com potencial

ATA DE REUNIÃO DE ACOMPANHAMENTO DOS TCAS 01 E 02 DE RESÍDUOS SÓLIDOS DOS MUNICÍPIOS DA REGIÃO SUL

3.3 o Município tem caminhão da coleta seletiva, sendo orientado a providenciar a contratação direta da associação para o recolhimento dos resíduos recicláveis,

MECANISMO ANTI-SPAM BASEADO EM AUTENTICAÇÃO E REPUTAÇÃO. Danilo Michalczuk Taveira

O valor da reputação dos pseudônimos é igual a 0,8 devido aos fal- sos positivos do mecanismo auxiliar, que acabam por fazer com que a reputação mesmo dos usuários que enviam

PORTARIA 047/UFSJ/PROGP, DE 07 DE MARÇO DE 2014

1º Nomear os professores CINTIA NANCI KOBORI (UFSJ), CHRISTIANO VIEIRA PIRES (UFSJ) e ANDRÉIA MARÇAL DA SILVA (UFSJ) para, sob a presidência da primeira, comporem a Banca

Misoprostol sublingual versus vaginal para indução do parto

Os desfechos primários incluíram os parâmetros relacionados à indução do trabalho de parto: intervalo transcorrido entre o início da indução (administração do

Valoração probabilística de empreendimentos de geração de energia elétrica a partir de bagaço de cana-de-açúcar em leilão de energia de reserva

O efetivo pagamento da(s) RECEITA(S) FIXA(S) estará condicionado ao início da operação comercial da(s) USINA(S), devendo os recursos financeiros associados a este

Protocolos de criopreservação de sementes de romã e juá.

Considerando a importância do assunto, a variabilidade existente nas características físicas e a ausência de dados na literatura especializada referente a