RECURSIVIDADE Análise de algoritmos UNISUL Ciência da Computação

Apresentação em tema: "RECURSIVIDADE Análise de algoritmos UNISUL Ciência da Computação"— Transcrição da apresentação:

1 RECURSIVIDADE Análise de algoritmos UNISUL Ciência da Computação
Prof. Maria Inés Castiñeira, Dra.

2 Recursividade um procedimento recursivo é aquele que contém uma ou mais chamadas a si mesmo a todo procedimento recursivo corresponde um não recursivo os programas recursivos são mais concisos aparente relação direta com a prova por indução matemática 232

3 Recursividade Cálculo de fatorial x! = se x <=0 1 senão x * (x-1)!
Implementação não recursiva int fatorial (int N)‏ { int result = 1; for (i=1; i<=N; i++)‏ result = result * i; return (result); } 235

4 Recursividade int fatorial (int N)‏ { if (N<= 1)‏ return(1); else
Implementação recursiva int fatorial (int N)‏ { if (N<= 1)‏ return(1); else return( N * fatorial(N-1)); } 236

5 Recursividade X= fatorial (4)‏ return( 4* fatorial(3) )‏
237

6 Análise de Recursividade
relação de recorrência – a função é definida em termos dela própria, recursivamente substituição repetida int fatorial (int N)‏ { if (N<= 1)‏ return(1); else return( N * fatorial(N-1)); }

7 Análise de Recursividade
T(n)‏ tempo de processar o algoritmo para entrada n em função do número de passos ou operações dominantes Fatorial T(n) = 1, se n = 0 = T(n-1) + 1, se n > 0 mas quanto é T(n-1) ?

8 T(n) - Fatorial = (T(n-1)) + 1 = (T(n-2) + 1) + 1 = T(n-2) + 2
..... forma geral, T(n) = T(n-k) + k, 1  k  n fazendo n = k, reduzimos a T(n) = n

9 número de chamadas  complexidade de uma chamada
A notação  Para procedimentos recursivos pode-se aplicar a seguinte técnica determina-se o número total de chamadas ao procedimento recursivo calcula-se a complexidade de execução de uma única chamada complexidade número de chamadas  complexidade de uma chamada 273

10 T(n) - Fatorial = (T(n-1)) + 1 = (T(n-2) + 1) + 1 = T(n-2) + 2
..... forma geral, T(n) = T(n-k) + k, 1  k  n fazendo n = k, reduzimos a T(n) = n  Fatorial = O(n) 10 10

11 Relação de recorrência
Como proceder para derivar uma relação de recorrência para a análise do tempo de execução de um algoritmo: • Determinar qual o tamanho n do problema. • Verificar que valor de n é usado como base da recursão. Em geral é um valor único (n=1, por exemplo), mas pode ser valores múltiplos. Vamos considerar esse valor como n0. • Determinar T(n0). Pode-se usar uma constante c, mas, em muitos, casos um número específico é necessário 11 273 11

12 Relação de recorrência
• T(n) é definido como uma soma de várias ocorrências de T(m) (chamadas recursivas), mais a soma de outras instruções efetuadas. Em geral, as chamadas recursivas estão relacionadas com subproblemas do mesmo tamanho f(n), definindo um termo a.T(f(n)) na relação de recorrência. • A relação de recorrência é definida por: – T(n) = c, se n = n0 – T(n) = a.T(f(n)) + g(n), caso contrário. 12 273 12

13 Derivando relação de recorrência
MergeSort(A, n) if n ≤ 1 return A return merge(MergeSort(A1, n/2), MergeSort(A2, n/2)) Relação de Recorrência do MergeSort T(1) = c T(n) = 2.T(n/2) + d.n 13 273 13

14 Resolvendo relação de recorrência
• Resolver uma relação de recorrência nem sempre é fácil. • Resolvendo uma relação de recorrência, determina-se o tempo de execução do algoritmo recursivo correspondente. • Relação de recorrência: T(n) = T(n1) + T(n2) T(na) + f(n) • É mais fácil quando temos a subproblemas de mesmo tamanho que é uma fração de n (por exemplo, n/b): – T(n) = a.T(n/b) + f(n) • Como resolver: – Método do desdobramento – Método master 14 273 14

15 Resolvendo a relação de recorrência: Desdobramento
Método do desdobramento Consiste em: – Usar (algumas poucas) substituições repetidamente até encontrar um padrão. – Escrever uma fórmula em termos de n e o número de substituições i. – Escolher i de tal forma que todas as referências a T() sejam referências ao caso base. – Resolver a fórmula. 15 273 15

16 Resolvendo a relação de recorrência: Desdobramento
Exemplo: divisão da pizza 16 273 16

17 Divisão da pizza 17 273 17

18 Divisão da pizza Corte – Fatia 1 – 2
2 – 4 3 – 7 4 – 11 5 – 16 6 – 22 7 – 29 O n-ésimo corte cria n novos pedaços. Logo o número total de pedaços obtidos com n cortes é chamado P(n): P(1) = 2 P(n) = P(n-1) + n, para n>=2 18 273 18

19 Divisão da pizza • Solução para o problema da pizza: – T(1) = 2
– T(n) = T(n – 1) + n , para n≥2 • Desdobrando a relação de recorrência: T(n) = T(n-1) + n T(n) = T(n-2) + (n-1) + n T(n) = T(n-3) + (n-2) + (n-1) + n ... T(n) = T(n-i) + (n-i+1) (n-1) + n 19 273 19

20 Divisão da pizza – T(1) = 2 – T(n) = T(n – 1) + n , para n≥2
T(n) = T(n-i) + (n-i+1) (n-1) + n • Caso base (T(1)) alcançado quando n-i=1, logo i=n-1 • T(n) = (n – 1) + n • T(n) = (n – 1) + n • T(n) = 1+ Somatória (em i de1até n) • T(n) = 1 + n.(n+1)/2 • Logo, T(n) = O(n^2) 20 273 20

21 Resolvendo relação de recorrência
• Resolvendo uma relação de recorrência, determina-se o tempo de execução do algoritmo recursivo correspondente. • Como resolver: 1- Método do desdobramento (pizza) 2- Método master 21 273 21

22 Método MASTER: relação de recorrência
•Teorema que resolve quase todas as recorrências. • T(n) da forma a.T(n/b) + f(n), a,b > 1 • Casos: 1. Se f(n) ∈ O(n^log ba - ε), para algum ε > 0, temos que: • T(n) ∈ Θ(n^log ba ). 2. Se f(n) ∈ O(n^log b a), temos que: • T(n) ∈ Θ(n^log b a. log n). 3. Se f(n) ∈ O(n^log b a + ε), para algum ε > 0 e se a.f(n/b)≤c.f(n) para algum c > 0 e n suficientemente grande, temos que: • T(n) ∈ Θ(f(n)). 22 273 22

23 Exemplo: mergesort MergeSort(A, n) if n ≤ 1 return A
return merge(MergeSort(A1, n/2), MergeSort(A2, n/2)) Relação de Recorrência do MergeSort T(1) = c T(n) = 2.T(n/2) + d.n 23 273 23

24 Método MASTER: exemplo mergesort
• T(n) da forma a.T(n/b) + f(n), a,b > 1 • MergeSort: – T(n) = 2.T(n/2) + n – a = b = 2 – f(n) = n • log b a = 1. Cai no caso 2. • Logo, T(n) = Θ(n.log n) 24 273 24

25 Método MASTER: exemplo 2
• T(n) da forma a.T(n/b) + f(n), a,b > 1 • Problema com Relação: T(n) = 9.T(n/3) + n – a = 9, b = 3 – f(n) = n • log b a = 2. Se ε = 1, Cai no caso 1. • Logo, T(n) = Θ(n^2). 25 273 25

26 Bibliografia Cormen, Leiserson e Rivest, ALGORITMOS: teoria e prática. Rio de Janeiro: Campus, 2002. FIGUEREDO, Jorge. Material didático de Técnicas e análise de algoritmos. UFCG. Disponível em