Nous pouvons le faire très efficacement en créant une structure que nous pouvons indexer en temps sous-linéaire.
Mais d'abord,
{-# LANGUAGE BangPatterns #-}
import Data.Function (fix)
Définissons f
, mais faisons-lui utiliser la «récursion ouverte» plutôt que de s'appeler directement.
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)
Vous pouvez obtenir un démo f
en utilisantfix f
Cela vous permettra de tester cela f
fait ce que vous voulez dire pour de petites valeurs de f
en appelant, par exemple:fix f 123 = 144
Nous pourrions mémoriser cela en définissant:
f_list :: [Int]
f_list = map (f faster_f) [0..]
faster_f :: Int -> Int
faster_f n = f_list !! n
Cela fonctionne passablement bien et remplace ce qui allait prendre du temps O (n ^ 3) par quelque chose qui mémorise les résultats intermédiaires.
Mais il faut toujours un temps linéaire pour indexer pour trouver la réponse mémorisée mf
. Cela signifie que des résultats comme:
*Main Data.List> faster_f 123801
248604
sont tolérables, mais le résultat ne s'adapte pas beaucoup mieux que cela. On peut faire mieux!
Tout d'abord, définissons un arbre infini:
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)
Et puis nous définirons un moyen de s'y indexer, afin que nous puissions trouver un nœud avec un index n
en temps O (log n) à la place:
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
... et nous pouvons trouver un arbre plein de nombres naturels pour être pratique pour ne pas avoir à jouer avec ces indices:
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
Puisque nous pouvons indexer, vous pouvez simplement convertir un arbre en liste:
toList :: Tree a -> [a]
toList as = map (index as) [0..]
Vous pouvez vérifier le travail jusqu'à présent en vérifiant que toList nats
vous[0..]
Maintenant,
f_tree :: Tree Int
f_tree = fmap (f fastest_f) nats
fastest_f :: Int -> Int
fastest_f = index f_tree
fonctionne comme avec la liste ci-dessus, mais au lieu de prendre un temps linéaire pour trouver chaque nœud, peut le poursuivre en temps logarithmique.
Le résultat est considérablement plus rapide:
*Main> fastest_f 12380192300
67652175206
*Main> fastest_f 12793129379123
120695231674999
En fait, c'est tellement plus rapide que vous pouvez passer et remplacer Int
par Integer
ci-dessus et obtenir des réponses ridiculement volumineuses presque instantanément
*Main> fastest_f' 1230891823091823018203123
93721573993600178112200489
*Main> fastest_f' 12308918230918230182031231231293810923
11097012733777002208302545289166620866358