¿Usando la programación dinámica en Haskell? [Advertencia: solución ProjectEuler 31 en el interior]
En la resolución del problema de projecteuler.net # 31 [SPOILERS por delante] (contando el número de formas de hacer 2 £ con las monedas británicas), quería usar la programación dinámica. Comencé con OCaml y escribí la siguiente programación breve y muy eficiente:
open Num
let make_dyn_table amount coins =
let t = Array.make_matrix (Array.length coins) (amount+1) (Int 1) in
for i = 1 to (Array.length t) - 1 do
for j = 0 to amount do
if j < coins.(i) then
t.(i).(j) <- t.(i-1).(j)
else
t.(i).(j) <- t.(i-1).(j) +/ t.(i).(j - coins.(i))
done
done;
t
let _ =
let t = make_dyn_table 200 [|1;2;5;10;20;50;100;200|] in
let last_row = Array.length t - 1 in
let last_col = Array.length t.(last_row) - 1 in
Printf.printf "%s\n" (string_of_num (t.(last_row).(last_col)))
Esto se ejecuta en ~ 8ms en mi computadora portátil. Si incremento la cantidad de 200 peniques a un millón, el programa aún encuentra una respuesta en menos de dos segundos.
Traduje el programa a Haskell (que definitivamente no fue divertido en sí mismo), y aunque termina con la respuesta correcta por 200 peniques, si aumente ese número a 10000, mi computadora portátil se detuvo (un montón de golpes). Aquí está el código:
import Data.Array
createDynTable :: Int -> Array Int Int -> Array (Int, Int) Int
createDynTable amount coins =
let numCoins = (snd . bounds) coins
t = array ((0, 0), (numCoins, amount))
[((i, j), 1) | i <- [0 .. numCoins], j <- [0 .. amount]]
in t
populateDynTable :: Array (Int, Int) Int -> Array Int Int -> Array (Int, Int) Int
populateDynTable t coins =
go t 1 0
where go t i j
| i > maxX = t
| j > maxY = go t (i+1) 0
| j < coins ! i = go (t // [((i, j), t ! (i-1, j))]) i (j+1)
| otherwise = go (t // [((i, j), t!(i-1,j) + t!(i, j - coins!i))]) i (j+1)
((_, _), (maxX, maxY)) = bounds t
changeCombinations amount coins =
let coinsArray = listArray (0, length coins - 1) coins
dynTable = createDynTable amount coinsArray
dynTable' = populateDynTable dynTable coinsArray
((_, _), (i, j)) = bounds dynTable
in
dynTable' ! (i, j)
main =
print $ changeCombinations 200 [1,2,5,10,20,50,100,200]
Me encantaría saber de alguien que conoce bien Haskell por qué el rendimiento de esta solución es tan malo.