Podemos hacer esto de manera muy eficiente haciendo una estructura que podamos indexar en tiempo sub-lineal.
Pero primero,
{-# LANGUAGE BangPatterns #-}
import Data.Function (fix)
Definamos f
, pero hagamos que use 'recursión abierta' en lugar de llamarse a sí mismo directamente.
f :: (Int -> Int) -> Int -> Int
f mf 0 = 0
f mf n = max n $ mf (n `div` 2) +
mf (n `div` 3) +
mf (n `div` 4)
Puede obtener un no conmemorado f
usandofix f
Esto le permitirá probar que f
hace lo que quiere decir con valores pequeños f
llamando, por ejemplo:fix f 123 = 144
Podríamos memorizar esto definiendo:
f_list :: [Int]
f_list = map (f faster_f) [0..]
faster_f :: Int -> Int
faster_f n = f_list !! n
Eso funciona aceptablemente bien y reemplaza lo que iba a tomar tiempo O (n ^ 3) con algo que memoriza los resultados intermedios.
Pero todavía lleva tiempo lineal solo indexar para encontrar la respuesta memorable mf
. Esto significa que resultados como:
*Main Data.List> faster_f 123801
248604
son tolerables, pero el resultado no escala mucho mejor que eso. ¡Podemos hacerlo mejor!
Primero, definamos un árbol infinito:
data Tree a = Tree (Tree a) a (Tree a)
instance Functor Tree where
fmap f (Tree l m r) = Tree (fmap f l) (f m) (fmap f r)
Y luego definiremos una forma de indexarlo, para que podamos encontrar un nodo con índice n
en tiempo O (log n) en su lugar:
index :: Tree a -> Int -> a
index (Tree _ m _) 0 = m
index (Tree l _ r) n = case (n - 1) `divMod` 2 of
(q,0) -> index l q
(q,1) -> index r q
... y podemos encontrar un árbol lleno de números naturales que sea conveniente para no tener que jugar con esos índices:
nats :: Tree Int
nats = go 0 1
where
go !n !s = Tree (go l s') n (go r s')
where
l = n + s
r = l + s
s' = s * 2
Como podemos indexar, puede convertir un árbol en una lista:
toList :: Tree a -> [a]
toList as = map (index as) [0..]
Puede verificar el trabajo hasta ahora verificando que toList nats
le da[0..]
Ahora,
f_tree :: Tree Int
f_tree = fmap (f fastest_f) nats
fastest_f :: Int -> Int
fastest_f = index f_tree
funciona igual que con la lista anterior, pero en lugar de tomar tiempo lineal para encontrar cada nodo, puede perseguirlo en tiempo logarítmico.
El resultado es considerablemente más rápido:
*Main> fastest_f 12380192300
67652175206
*Main> fastest_f 12793129379123
120695231674999
De hecho, es mucho más rápido que puede pasar y reemplazar Int
con el Integer
anterior y obtener respuestas ridículamente grandes casi instantáneamente
*Main> fastest_f' 1230891823091823018203123
93721573993600178112200489
*Main> fastest_f' 12308918230918230182031231231293810923
11097012733777002208302545289166620866358