Haskell：使用 List Monad 计算周期

Question

-- 1. Graph structure: nodes and adjacency matrix (i.e. the edges) 
data Node = A | B | C | D | E | F deriving (Show,Eq,Ord)

adj :: (Node,Node) -> Bool
adj p = case p of
  (A,B) -> True
  (A,C) -> True  
  (B,C) -> True
  (B,F) -> True
  (C,D) -> True
  (D,E) -> True
  (E,B) -> True
  (E,F) -> True
  (F,A) -> True
  (_,_) -> False

type Path = [Node]

-- 2. Auxiliary functions
adjacentNodes :: Node -> [Node] -> [Node]
adjacentNodes n ns = filter (\x -> adj(n,x)) ns

allNodes :: [Node]
allNodes = [A,B,C,D,E,F]

choice :: ([a],[a]) -> [a]
choice = uncurry (++)

-- 3. To do
addtoEnd :: Path -> [Node] -> [Path]
addtoEnd p ns = undefined

hCycles :: Node -> [Path]
hCycles n = undefined

我有这个代码（它是给我们的，我不能改变它或类型）并且需要使用 list monad（和 do 表示法）定义函数 hCycles。 hCycles 应该为图像中图形的任何通用节点计算哈密顿循环。

问题是我不太确定如何用 list monad 来做到这一点......尽管如此，我想我有这个函数的第一个版本：

hCycles :: Node -> [Path]
hCycles n = do 
            p <- [[n]]
            nextNode <- adjacentNodes n allNodes
            if n == nextNode
            then [p]
            else addtoEnd p allNodes

if/else 仍然有一个奇怪的行为，因为 hCycles 没有被再次调用，我什至不认为它是递归的......我该如何解决这个问题？

Answer 1

您好，我想是时候给您一些可以解决您问题的版本了：

hCycles :: Node -> [Path]
hCycles n = 
    filter isValidPathLength $ map (n:) $ go [] (adjacentNodes n allNodes)
    where
    isValidPathLength path =
        length path == length allNodes + 1
    -- note: go will only care about a path to n 
    -- but will take care of not visiting nodes two-times
    go _ [] = [] -- fail if there is no node left to discover
    go visited toVisit = do
        cur <- toVisit
        if cur == n then
            pure [n] -- found n
        else do
            let neighboursToVisit = filter (`notElem` visited) $ adjacentNodes cur allNodes
            pathToEnd <- go (cur:visited) neighboursToVisit
            pure $ cur:pathToEnd

我注意到您的adj 不适合您的图片，因此我将其更改为

adj :: (Node,Node) -> Bool
adj p = case p of
  (A,B) -> True
  (A,C) -> True  
  (B,C) -> True
  (B,F) -> True
  (C,D) -> True
  (D,E) -> True
  (E,B) -> True
  (E,F) -> True
  (F,A) -> True
  (_,_) -> False

（你的好像不是有向图）

你会得到：

> hCycles A
[[A,B,C,D,E,F,A],[A,C,D,E,B,F,A]]

一些注释：

我不关心这里的性能（例如，有更好的数据结构来管理 visited 然后是一个列表） - 这个是蛮力的深度优先搜索 - 如果你愿意，你可以适应它BFS - 这是一个很好的练习 IMO（你可能想摆脱 do 符号的东西......嘿，你要求它）

Answer 2

在 list monad 中的一行：

x <- f y

期望f 返回一个列表。 x 将依次使用列表中的每个值进行实例化，因此 do 子句的其余部分将使用这些值中的每一个运行。

您将看到adjacentNodes 返回一个节点列表。因此，从n 开始，您可以像这样考虑它连接的每个节点：

nextNode <- adjacentNode n allNodes

编写这个函数：

steps :: [Nodes] -> Path -> [Path]
steps _ [] = fail "Need a node to start with."
steps ns path@(n:rest) = do
   nextNode <- adjacentNode n ns
   guard $ not $ elem nextNode path   -- Stop if we've already visited this node.
   return $ nextNode : path

你可以把它想象成寻找单一路径的算法，它（感谢 list monad）神奇地找到所有可能的路径。这不是完整的答案，但它应该足以让您开始使用。

（注意：我还没有实际测试过这段代码。）