Construção de Algoritmos II Aula 06

Transcrição

1 exatasfepi.com.br Construção de Algoritmos II Aula 06 André Luís Duarte Porque mil anos são aos teus olhos como o dia de ontem que passou, e como a vigília da noite. Salmos 90:4

2 Recursividade e complexidade Módulos recursivos Introdução à de Algoritmo 2

3 Módulos recursivos Podemos ativar um módulo de forma recursiva Para isso, temos que inserir a ativação do módulo, dentro do próprio módulo usando um critério de parada Isso é chamado de ativação (ou chamada) recursiva 3

4 Módulos recursivos Para que ativação seja correta, devemos pensar em quando a chamada será finalizada Devemos conhecer a função de recursividade Objetivo é resolver um problema mais simples (diminuir o problema) Segue a ideia de dividir para conquistar 4

5 Pensando recursivamente Remover todas as bolinhas de uma caixa com 3 bolinhas 5

6 Pensando recursivamente Remover 1 bolinha e tento resolver outro problema menor Remover todas as bolinhas de uma caixa com 2 bolinhas 6

7 Módulos recursivos Remover 1 bolinha e tento resolver outro problema menor Remover todas as bolinhas de uma caixa com 1 bolinha 7

8 Módulos recursivos Remover 1 bolinha e tento resolver outro problema menor Remover todas as bolinhas de uma caixa vazia (resolvido) 8

9 Módulos recursivos Temos que pensar em dois elementos Generalização Representação genérica da função Caso base Critério de parada 9

10 Módulos recursivos Temos que pensar em dois elementos Generalização Representação genérica da função Caso base Remover todas as bolinhas de uma caixa com n-1 bolinhas Critério de parada Se a caixa estiver vazia pare 10

11 Módulos recursivos Fatorial Generalização 5! = 5 * 4 * 3 * 2 * 1 7! = 7 * 6 * 5 * 4 * 3 * 2 * 1 n! = n * (n 1) * (n 2) * * 1 Caso base 0! = 1 11

12 Módulos recursivos inicio módulo fat(inteiro n) se(n = 0)então retorne 1; senão retorne n * fat(n-1); fimmódulo; escreva(fat(4)); fim 12

13 Módulos recursivos Pilha inicio módulo fat(inteiro n) se(n = 0)então retorne 1; senão retorne n * fat(n-1); fimmódulo; escreva(fat(4)); fim fat(4) n 4 * fat(3) Topo 13

14 Módulos recursivos Pilha inicio módulo fat(inteiro n) se(n = 0)então retorne 1; senão retorne n * fat(n-1); fimmódulo; escreva(fat(4)); fim fat(3) n 3 fat(4) n 4 * fat(2) * fat(3) Topo 14

15 Módulos recursivos Pilha inicio módulo fat(inteiro n) se(n = 0)então retorne 1; senão retorne n * fat(n-1); fimmódulo; escreva(fat(4)); fim fat(2) n 2 fat(3) n 3 fat(4) n 4 * fat(1) * fat(2) * fat(3) Topo 15

16 Módulos recursivos Pilha inicio módulo fat(inteiro n) se(n = 0)então retorne 1; senão retorne n * fat(n-1); fimmódulo; escreva(fat(4)); fim fat(1) n 1 fat(2) n 2 fat(3) n 3 fat(4) n 4 * fat(0) * fat(1) * fat(2) * fat(3) Topo 16

17 Módulos recursivos fat(0) Pilha Topo retorna 1 inicio módulo fat(inteiro n) se(n = 0)então retorne 1; senão retorne n * fat(n-1); fimmódulo; escreva(fat(4)); fim fat(1) n 1 fat(2) n 2 fat(3) n 3 fat(4) n 4 * fat(0) * fat(1) * fat(2) * fat(3) 17

18 Módulos recursivos Pilha inicio módulo fat(inteiro n) se(n = 0)então retorne 1; senão retorne n * fat(n-1); fimmódulo; escreva(fat(4)); fim fat(1) n 1 fat(2) n 2 fat(3) n 3 fat(4) n 4 * 1 * fat(1) * fat(2) * fat(3) Topo 18

19 Módulos recursivos Pilha inicio módulo fat(inteiro n) se(n = 0)então retorne 1; senão retorne n * fat(n-1); fimmódulo; escreva(fat(4)); fim fat(2) n 2 fat(3) n 3 fat(4) n 4 * 1 * fat(2) * fat(3) Topo 19

20 Módulos recursivos Pilha inicio módulo fat(inteiro n) se(n = 0)então retorne 1; senão retorne n * fat(n-1); fimmódulo; escreva(fat(4)); fim fat(3) n 3 fat(4) n 4 * 2 * fat(3) Topo 20

21 Módulos recursivos Pilha inicio módulo fat(inteiro n) se(n = 0)então retorne 1; senão retorne n * fat(n-1); fimmódulo; escreva(fat(4)); fim fat(4) n 4 * 6 Topo 21

22 Módulos recursivos Pilha inicio módulo fat(inteiro n) se(n = 0)então retorne 1; senão retorne n * fat(n-1); fimmódulo; escreva(fat(4)); fim 22

23 Exercício de fixação Crie um módulo com chamada recursiva que exiba a soma dos 5 primeiros inteiros positivos Ilustre o funcionamento de sua solução mostrando a pilha de execução 23

24 Exercício de fixação Crie um módulo com chamada recursiva que exiba os 10 primeiros pares a partir de um valor fornecido pelo usuário Crie um módulo com chamada recursiva que exiba a soma de todos os números inteiros entre um intervalo definido pelo usuário Crie um módulo com chamada recursiva que exiba os 10 primeiros impares a partir de uma valor fornecido pelo usuário 24

25 Temos visto que um algoritmo é usado para solucionar um problema de forma organizada e bem definida da seguinte forma: Entrada Processamento Saída 25

26 Instância de problema São todas as possibilidades usadas na entrada e que gera uma saída particular <9 7 2> Ordena <2 7 9> < > Ordena < > 26

27 Porque analisar a eficiência de um algoritmo? Calcular um sistema de equações lineares de ordem 3 27

28 Como medir a eficiência? Estudo experimental ou benchmark Implementar o algoritmo Executar com diferentes instâncias de problemas Medir o tempo de execução 28

29 Limitações Necessidade de implementar o algoritmo em uma linguagem Não podemos experimentar todos os cenários possíveis Compilador, SO, hardware, etc, influenciam no tempo de execução 29

30 Maneira ideal Contar o número de operações relevantes ao algoritmo Operações primitivas Operações aritméticas Comparações Leitura Escrita etc 30

31 Modelo de Computação Devemos definir o modelo onde nossa análise será realizada RAM (Random Access Machine) Instruções são executadas sequencialmente (não há concorrência) Apresenta instruções presentes em computadores reais Cada instrução é executada em tempo constante 31

32 Quantas ações são necessárias para calcularmos a média aritmética dos dados armazenados em um vetor

33 Exemplo soma 0; media 0; para i de o até n passo 1 faça soma fimpara; soma + vet[i]; media soma / n; Quantas operações podemos contar? 33

34 Exemplo soma 0; 1 media 0; 1 para i de o até n passo 1 faça n + 1 soma soma + vet[i]; n fimpara; media soma / n; 1 Qual a soma do tempo total? 2 n

35 Não nos interessa o número exato do tempo mas sim na ordem de grandeza 2n + 4 => o n é o elemento principal pois se ele for muito grande as constantes 2 e 4 não influenciam muito na ordem de grandeza Pense no n com 2, 10, 100, de elementos O n é o fator que possui maior influência na ordem de grandeza 35

36 Dizemos no exemplo anterior: T(n) = O(n) Analisando tempo de execução => T(n) é chamada função complexidade de tempo Analisando memória necessária => T(n) é chamada função complexidade de espaço n em O(n) representa o tamanho da entrada 36

37 Exercício: encontrar o maior valor em um vetor [ ] pos 0; maior 1; para i de 2 até 6 passo 1 faça se (v[i] > v[maior])então maior i; fimse; fimpara; 37

38 Exercício: encontrar o maior valor em um vetor [ ] pos 0; 1 maior 1; 1 para i de 2 até 6 passo 1 faça n 1 se (v[i] > v[maior])então n 1 maior i; n 1* fimse; fimpara; 3n 1 * consideramos o pior caso 38

39 Bubblesort vet = [7, 6, 5, 4, 3, 2, 1]; tam 7; para i de tam até 1 passo 1 faça fimpara; para j de 1 até i passo 1 faça if(vet[j] > vet[j+1])então fimse; fimpara; aux = vet[j]; vet[j] vet[j+1]; vet[j+1] aux; 39

40 Bubblesort O(n 2 ) vet = [7, 6, 5, 4, 3, 2, 1]; tam 7; 1 para i de tam até 1 passo 1 faça n para j de 1 até i passo 1 faça n 1, n 2, n 3, n 4, n 5, n 6 se(vet[j] > vet[j+1])então n 1,... fimse; fimpara; aux = vet[j]; n 1,... vet[j] vet[j+1]; n 1,... vet[j+1] aux; n 1,... fimpara; n * 30n = n * n = n 2 40

41 Comparando T(n) = O(n) (linear) n = 100 => T(n) = 100 T(n) = O(n 2 ) (quadrática) n = 100 => T(n) = = Se precisamos decidir qual algoritmo usar, devemos preferir o de menor complexidade 41

42 Pior caso => O É o que devemos nos preocupar Melhor caso => Ω Para efeito de comparação Caso médio => Θ Pode ser muito complexo de ser obtido 42

43 Pior caso (O): valor que não existe no vetor vet = [7, 6, 5, 4, 3, 2, 1]; pos 1; i 1; k = 8; // chave a ser buscada enquanto(i < tam AND pos = 1)faça se (vet[i] = k)então fimse; pos i; i i + 1; fimenquanto; 43

44 Pior caso: valor que não existe no vetor vet = [7, 6, 5, 4, 3, 2, 1]; pos 1; 1 i 1; 1 k = 8; // chave a ser buscada 1 enquanto(i < tam AND pos = 1)faça n + 1 se (vet[i] = k)então fimse; pos i; 1 n i i + 1; n fimenquanto; 3n

45 Pior caso: valor que não existe no vetor vet = [7, 6, 5, 4, 3, 2, 1]; pos 1; i 1; T(n) = O(n) k = 8; // chave a ser buscada enquanto(i < tam AND pos = 1)faça se (vet[i] = k)então fimse; pos i; i i + 1; fimenquanto; 45

46 Melhor caso (Ω): valor está na 1ª posição do vetor vet = [7, 6, 5, 4, 3, 2, 1]; pos 1; i 1; k = 8; // chave a ser buscada enquanto(i < tam AND pos = 1)faça se (vet[i] = k)então fimse; pos i; i i + 1; fimenquanto; 46

47 Melhor caso: valor está na 1ª posição do vetor vet = [7, 6, 5, 4, 3, 2, 1]; pos 1; 1 i 1; 1 k = 7; // chave a ser buscada 1 enquanto(i < tam AND pos = 1)faça 2 se (vet[i] = k)então 1 fimse; pos i; 1 i i + 1; 1 fimenquanto; 8 47

48 Melhor caso: valor está na 1ª posição do vetor vet = [7, 6, 5, 4, 3, 2, 1]; pos 1; i 1; T(n) = Ω(1) k = 8; // chave a ser buscada enquanto(i < tam AND pos = 1)faça se (vet[i] = k)então fimse; pos i; i i + 1; fimenquanto; 48

49 Para facilitar a análise vamos considerar a instrução mais relevante No nosso exemplo o se é a instrução mais relevante pois é ela que controla quantas vezes o laço vai ser executado se não for o pior caso 49

50 Caso médio (Θ): média das execuções vet = [7, 6, 5, 4, 3, 2, 1]; pos 1; i 1; k = 8; // chave a ser buscada enquanto(i < tam AND pos = 1)faça se (vet[i] = k)então // vamos analisar seu o comportamento fimse; pos i; i i + 1; fimenquanto; 50

51 Caso médio: média das execuções vet = [7, 6, 5, 4, 3, 2, 1]; pos 1; i 1; k = 7; // chave a ser buscada enquanto(i < tam AND pos = 1)faça se (vet[i] = k)então ( n 1 + n) fimse; pos i; i i + 1; fimenquanto; 51

52 Temos que: n n 1+n= i=1 i Podemos dizer que: n i=1 i n 2 (n+1) n (n+1) 2 Logo, média = n (n+1) 2 n (n+1) 2 n 52

53 Caso médio: média das execuções vet = [7, 6, 5, 4, 3, 2, 1]; pos 1; i 1; T(n) = Θ(n) k = 8; // chave a ser buscada enquanto(i < tam AND pos = 1)faça se (vet[i] = k)então fimse; pos i; i i + 1; fimenquanto; 53

54 Para entradas pequenas, a escolha do algoritmo não importa tanto 54

55 A medida que a quantidade de entradas aumenta, a escolha fica mais seletiva 55

56 Comportamento assintótico Comportamento da função para valores muito grande - <= n <= + 56

57 Note que o comportamento do crescimento não é influenciado pelas constantes Logo, podemos desconsiderá-las 57

58 Analisando o comportamento das curvas para valores pequenos qual escolher? 58

59 Analisando o comportamento das curvas para valores grandes (assintótico) qual escolher? 59

60 Devemos desconsiderar as constantes no crescimento da função somente para valores muito grandes 60

61 Dizemos que existe um valor de tamanho de entrada chamado n 0 que a partir dele o algoritmo é pior do que outros 61

62 5n => n0 = 1, 5n 2 => n 0 = 2, 2 n => n 0 = 9 62

63 Exemplo de gráficos das notações de complexidade 63

64 À direita de n0 o valor de f(n) sempre está entre c 1 g(n) e c 2 g(n) inclusive 64

65 À direita de n0 o valor de f(n) sempre está em ou abaixo de cg(n) 65

66 À direita de n0 o valor de f(n) sempre está em ou acima de cg(n) 66

67 67