Haskell - 使用滑动窗口在 2D 网格上进行模式匹配

Question

我正在尝试实现一个函数来匹配二维网格内 Haskell 中的特定模式。例如，如果我的网格定义如下：

grid = [[0,0,0,0],
        [0,1,1,0],
        [0,1,1,0],
        [0,0,0,0]] 

我正在寻找的模式是：

pattern = [[1, 1], 
           [0, 0]]

我希望它返回网格中左上角元素的索引。在这种情况下，(2,1)。我的函数有以下类型：

matches2d :: Eq a 
          => [[a]]          -- ^ The 2D grid to match over 
          -> [[a]]          -- ^ The 2D pattern to match
          -> [(Int, Int)]   -- ^ Top left corner of sections matching the pattern

我不确定如何解决这个问题。我在这里尝试使用的方法是网格上模式的滑动窗口，但我现在一直在尝试实现类似的东西。到目前为止，这是我所拥有的，但我认为我错过了它背后的一些逻辑：

matches2d :: Eq a => [[a]] -> [[a]] -> [(Int, Int)] 
matches2d _ [] = [] 
matches2d f (x:xs) = matcher x pattern 
  where matcher x y (x:xs) = sort x == sort y

提前感谢您的帮助。

Answer 1

用递归解决它。

这是一些迭代开发。在下文中，您首先需要了解列表推导和 zipWith 函数。它是解方程的最简单的函数

zipWith <b>f</b> (x:xs) (y:ys) = <b>f</b> x y : zipWith <b>f</b> xs ys

或者，如果您熟悉zip，

zipWith <b>f</b> xs ys = [<b>f</b> x y | (x,y) &lt;- zip xs ys]

还有，

and (x:xs) = x && and xs
           =  all (\x -> x == True) xs
           =  all (\x -> x) xs
           =  all id xs

这样，

1.

matches2d_1 :: Eq a => [[a]] -> [[a]] -> Bool
matches2d_1 pattern xss = 
    and (map and (zipWith (zipWith (==)) pattern xss))     -- does it match?
    ||  matches2d_1 pattern (drop 1 xss)            -- or start at next row
    ||  matches2d_1 pattern (map (drop 1) xss)      -- or start at next column

这在极端情况下是错误的，但给出了一个总体思路。它的核心是and (zipWith (\a b -> and (zipWith (==) a b)) pattern xss) 位。

请注意，它只为我们提供了第一个成功结果的指示，但我们想要所有这些结果，因此，一个列表。因此，

2.

matches2d_2 :: Eq a => [[a]] -> [[a]] -> [Bool]
matches2d_2 pattern xss    | shorter xss pattern       = []  -- not enough rows
matches2d_2 pattern (xs:_) | shorter xs (head pattern) = []  -- not enough columns
matches2d_2 pattern xss = 
    [True | and (map and (zipWith (zipWith (==)) pattern xss))]  -- this match
    ++  matches2d_2 pattern (drop 1 xss)            -- or other
    ++  matches2d_2 pattern (map (drop 1) xss)      --      ones...
shorter a b = -- length a < length b
       .... implement it better

这会处理边缘情况，但不会返回实际成功 结果它仍然只报告每个结果。

3.

matches2d :: Eq a => [[a]] -> [[a]] -> [(Int,Int)]
.....

对以上内容进行扩充应该可以得到我们想要的实际结果。

4.

按照规范进行工作实施，接下来我们可以考虑效率。它会重复做任何多余的工作吗？这可以避免吗？

Answer 2

所以解决这个问题花了我一些时间。我需要定义另一个辅助函数和其他一些函数来让它工作。归结起来，有一个slicer 函数：它采用一个完整的网格和两个元组，然后提取子网格，其中行在第一个元组的范围内，第二个元组的列。它的定义如下：

slicer :: [[a]] -> (Int, Int) -> (Int, Int) -> [[a]]
slicer [] _ _ = []
slicer a (x1,x2) (y1,y2) =form (head ( [[index a (i,j)|i<-[x1..x2-1],j<-[y1..y2-1]]])) (x2-x1,y2-y1)

我还需要一个函数来返回网格中给定索引处的值，index：

index :: [[a]] -> (Int, Int) -> a
index (b:bb) (0,0) = head b
index (c:cc) (0,y) = index [(tail c)] (0,y-1)
index (d:dd) (x,y) = index dd (x-1,y)

接下来是定义helper 函数。这花费了该函数的大部分工作。它有助于将操作“嵌套”在整个网格上。它的整个功能是在整个网格上滑动固定大小的窗口并找到匹配项。一旦完成，它会给出该匹配窗口最左上角的坐标。它的定义是这样的：

helper :: Eq a => [[a]] -> [[a]] -> (Int, Int, Int) -> [(Int, Int)]
helper x _ (l, m, n) | (l > length x) = []
helper x y (l, m, n) | (n > length (concat (take 1 x))) = helper x y (l+1, 0, (length (concat (take 1 y))))
helper x y (l, m, n) | (slicer x (l, (length y) + l) (m, n) == y) = [(l, m)] ++ helper x y (l, (m+1), (n+1))
helper x y (l, m, n) | (slicer x (l, (length y) + l) (m, n) /= y) = [] ++ helper x y (l, (m+1), (n+1))

最后，在所有这些子功能之后，是时候真正制作我从一开始就尝试制作的功能了。具有讽刺意味的是，它是其中最简单的，因为它只在网格长度上采用给定的模式。

matcher :: Eq a => [[a]] -> [[a]] -> [(Int, Int)]
matcher x y = helper x y (0, 0, (length (concat (take 1 y))))