在 Haskell 中使用 Data.Map 进行动态编程？

Question

我正在尝试在 Haskell 中实现一个简单的 dp 算法（这是针对 Project Euler 的 Collat​​z 猜想问题）；这是等效的c++：

map<int,int> a;
int solve(int x) {
  if (a.find(x) != a.end()) return a[x];
  return a[x] = 1 + /* recursive call */;
}

所以我在 Haskell 中编写的代码最终看起来像这样：

solve :: (Memo, Int) -> (Memo, Int)
solve (mem, x) =
 case Map.lookup x mem of
  Just l -> (mem, l)
  Nothing -> let (mem', l') = {- recursive call -}
                 mem'' = Map.insert x (1+l') mem'
             in (mem'', 1+l')

（我认为我只是在这里重新实现一个状态单子，但暂时不要介意。）调用solve的代码试图找到它可以为参数提供的最大值K=1e6：

foldl'
 (\(mem,ss) k ->
   let (mem',x') = solve (mem, k)
   in (mem', (x', k):ss))
 (Map.singleton 1 1, [(1,1)]) [2..100000]

上面编写的代码因堆栈溢出而失败。这是意料之中的，我理解，因为它建立了一个非常大的未评估的重击。所以我尝试使用

x' `seq` (mem', (x',k):ss)

在 foldl' 内，它计算 K=1e5 的正确答案。但这对于 K=1e6 失败（12 秒内堆栈溢出）。然后我尝试使用

mem'' `seq` l' `seq` (mem'', 1+l')

在求解的最后一行，但这没有任何区别（堆栈仍然溢出）。然后我尝试使用

mem'' `deepseq` l' `seq` (mem'', 1+l')

这非常慢，大概是因为 deepseq 遍历整个 map mem''，使得算法的时间复杂度是二次的，而不是 n*log(n)。

实现这一点的正确方法是什么？我被卡住了，因为我无法弄清楚如何使整个计算变得严格，而且我不太确定计算的哪一部分导致堆栈溢出，但我怀疑它是地图。我可以使用，例如，数组，但我想了解我在这里做错了什么。

Answer 1

当您使用 32 位有符号整数类型时，堆栈溢出不会消失。对于某些起始值，链离开 32 位范围并进入负数的无限循环。使用Integer 或Int64 或Word64。