O termo Programação Dinâmica é um bocado infeliz.

Transcrição

1 Programação Dinâmica Fernando Lobo Algoritmos e Estrutura de Dados II 1 / 18 Programação Dinâmica Outra técnica de concepção de algoritmos, tal como Divisão e Conquista ou Estratégias Greedy. O termo Programação Dinâmica é um bocado infeliz. Programação sugere programação de computadores. Dinâmica sugere valores que mudam ao longo do tempo. A técnica de Programação Dinâmica não tem que ver com uma coisa nem outra! 2 / 18

2 O que é então a Programação Dinâmica? É uma técnica de resolução de problemas. A ideia é resolver subproblemas pequenos e armazenar os resultados. Esses resultados são depois utilizados para resolver subproblemas maiores (e armazenando novamente os resultados). E assim sucessivamente até se resolver o problema completo. 3 / 18 Comparação com Divisão e Conquista Semelhanças Para resolver um problema combinamos as soluções de subproblemas. Diferenças Divisão e Conquista é eficiente quando os subproblemas são todos distintos. Se tivermos que resolver várias vezes o mesmo subproblema, a Divisão e Conquista torna-se ineficiente. Com Programação Dinâmica cada subproblema é resolvido apenas uma vez. 4 / 18

3 Exemplos de Programação Dinâmica A melhor maneira de aprender Programação Dinâmica é ver alguns exemplos. Exemplo simples: Calcular o n-ésimo número da sequência de Fibonacci. F n = 0, se n = 0 1, se n = 1 F n 1 + F n 2, se n > 1 5 / 18 Pseudocódigo Fib-Rec(n) if n == 0 return 0 if n == 1 return 1 return Fib-Rec(n 1) + Fib-Rec(n 2) Este algoritmo é muito mau. Porquê? 6 / 18

4 Vejamos o que acontece com n = 5 7 / 18 Fibonacci: Algoritmo de Divisão e Conquista Estamos a calcular a mesma coisa várias vezes! Pode-se provar que F n+1/f n = F n > 1.6 n Qual a complexidade do algoritmo? Fn resulta da soma das folhas da árvores. Fn > 1.6 n = árvore tem pelo menos 1.6 n folhas. Logo, o algoritmo tem complexidade Ω(1.6 n ), o que é muito mau. Experimentem programá-lo e usar n = / 18

5 Fibonacci: Algoritmo de Divisão e Conquista No exemplo com n = 5, calculamos: F4 1 vez F3 2 vezes F2 3 vezes F1 5 vezes F0 3 vezes É trabalho desnecessário. Só deveríamos calcular cada F i uma e uma só vez. Podemos fazê-lo usando Programação Dinâmica. 9 / 18 Fibonacci: Algoritmo de Programação Dinâmica A ideia é resolver o problema de baixo para cima, começando pelos casos base e armazenando as soluções dos subproblemas. Fib-PD(n) F [0] = 0 F [1] = 1 for i = 2 to n F [i] = F [i 1] + F [i 2] return F [n] Complexidade temporal? Θ(n). Complexidade espacial? Θ(n). 10 / 18

6 Fibonacci: Algoritmo de Programação Dinâmica Para calcular F i basta ter armazenado as soluções dos dois subproblemas F i 1 e F i 2. Logo, podemos reduzir a complexidade espacial de Θ(n) para Θ(1). Fib-PD-v2(n) if n == 0 return 0 if n == 1 return 1 back2 = 0 back1 = 1 for i = 2 to n next = back1 + back2 back2 = back1 back1 = next return next 11 / 18 Outro exemplo: Coeficientes binomiais Ck n = ( ) n k = n! k!(n k)! ( n k) é o número de combinações de n elementos k a k. Por palavras mais simples: número de maneiras distintas de escolher grupos de k elementos a partir de um conjunto de n elementos. Exemplo: Dado um conjunto de 10 alunos, quantos grupos distintos de 3 alunos se podem fazer? Resp: ( ) 10 3 = 10! 3!7! = 120 A aplicação directa da fórmula pode facilmente dar um overflow aritmético por causa dos factoriais, mesmo que o resultado final caiba perfeitamente num inteiro. 12 / 18

7 Coeficientes binomiais (cont.) Podemos definir ( n k) de modo recursivo. ( ) ( n k = n 1 ) ( k 1 + n 1 ) k 1 a parcela: k-ésimo elemento pertence ao grupo é necessário escolher k 1 dos restantes n 1 elementos. 2 a parcela: k-ésimo elemento não pertence ao grupo é necessário escolher k dos restantes n 1 elementos. Casos base: k = 0, n = k ( n k) = 1 13 / 18 Algoritmo naive (de força bruta) Comb(n, k) if k == 0 or n == k return 1 else return Comb(n 1, k 1) + Comb(n 1, k) 14 / 18

8 Solução com Programação Dinâmica Comb-PD(n, k) for i = 0 to n for j = 0 to min(i, k) if j == 0 or j == i A[i, j] = 1 else A[i, j] = A[i 1, j 1] + A[i 1, j] return A[n, k] 15 / 18 Exemplo de execução: Comb-PD(5,3) i j / 18

9 Memoization É uma técnica semelhante à Programação Dinâmica. Mantém o algoritmo recursivo na forma top-down. A ideia é inicializar as soluções dos subproblemas com o valor Desconhecido. Depois, quando queremos resolver um subproblema, verificamos primeiro se já foi resolvido. Se sim, retornamos a solução previamente armazenada. Se não, resolvemos o subproblema e armazenamos a solução. Cada subproblema só é resolvido uma vez. 17 / 18 Versão memoized de Comb Comb-Memoized(n, k) for i = 0 to n for j = 0 to min(i, k) C[i, j] = unknown return M-Comb(n, k) M-Comb(i, j) if C[i, j] == unknown if j == 0 or j == i C[i, j] = 1 else C[i, j] = M-Comb(i 1, j 1) + M-Comb(i 1, j) return C[i, j] 18 / 18