Question

假设我有一个Haskell算法，它通过递归进展到笛卡尔平面，其中每个x / y坐标都有一个特定的值。

位置（0,0）是已知的，可以通过回溯到原点来计算彼此。

例如，要查看（0,3）我需要查看（-1,2），（0,2）和（1,2），它们必须依次看（-2,1）），（ - 1,1），（0,1）和（-1,1），（0,1），（1,1）和（0,1），（1,1），（2,1））分别。

为了避免（-1,1）和（0,1）被计算两次，有什么办法可以创建一个数据结构，这样算法就可以先查看某个位置是否已经过了已经计算过，如果不是，那么只进行计算？

谢谢：）

Answer 1

这听起来像是备忘，因为m09和cdk建议可能就是你要找的东西。但是如果你想要一个返回位置数组的算法，那么简单的盒装数组（意思是它们保持惰性值）和一些knot tying可以给你一个很好的声明性解决方案（对于丑陋的代码感到抱歉）

import Data.Array

-- for positive u
plane :: Int -> Array (Int,Int) Int
plane u = let knownOrigin = ((0,0) , 0)
              l = negate u
              otherCoords = [ (x,y) | let cs = [l .. u] 
                                    , x <- cs , y <- cs
                                    , (x,y) /= (0,0) 
                                    ]
              a = array ((l,l),(u,u)) $
                    knownOrigin : map solution otherCoords

              -- example recursive thing, referenceing lazy values in 'a':
              solution c@(x,y) = let x' | x <0 = x+1
                                        | x >0 = x-1
                                        | x==0 = 0
                                     y' | y <0 = y+1 
                                        | y >0 = y-1
                                        | y==0 = 0
                                  in (c , a ! (x',y') + 1)
           in a

您还可以使用Map或向量，或任何其他最适合您的问题的懒惰结构。

Haskell存储数据随着算法的进展

1 个答案: