haskell中的回溯

我必须遍历一个矩阵，说出每种类型有多少“特征区域”

特征区域定义为值为n或大于n的元素相邻的区域

例如，给定矩阵：

0 1 2 2
0 1 1 2
0 3 0 0

有一个类型1的单一特征区域，它等于原始矩阵：

0 1 2 2
0 1 1 2
0 3 0 0

类型2有两个特征区域：

0 0 2 2    0 0 0 0
0 0 0 2    0 0 0 0
0 0 0 0    0 3 0 0

以及类型3的一个特征区域：

0 0 0 0 
0 0 0 0
0 3 0 0 

因此，对于函数调用：

countAreas [[0,1,2,2],[0,1,1,2],[0,3,0,0]] 

结果应该是

[1,2,1]

我还没有定义countarea，当我的

visit

函数没有更多可能移动的方块时，我被卡住了，无法进行正确的递归调用。我对函数式编程还不熟悉，但对于如何在这里实现回溯算法，我仍在挠头。看看我的代码，我能做些什么来更改它

move_right :: (Int,Int) -> [[Int]] -> Int -> Bool
move_right (i,j) mat cond | (j + 1) < number_of_columns mat && consult (i,j+1) mat /= cond = True
               | otherwise = False

move_left :: (Int,Int) -> [[Int]] -> Int -> Bool
move_left (i,j) mat cond | (j - 1) >= 0 && consult (i,j-1) mat /= cond = True
               | otherwise = False

move_up :: (Int,Int) -> [[Int]] -> Int -> Bool
move_up (i,j) mat cond | (i - 1) >= 0 && consult (i-1,j) mat /= cond = True
               | otherwise = False

move_down :: (Int,Int) -> [[Int]] -> Int -> Bool
move_down (i,j) mat cond | (i + 1) < number_of_rows mat && consult (i+1,j) mat /= cond = True
               | otherwise = False

imp :: (Int,Int) -> Int
imp (i,j) = i


number_of_rows :: [[Int]] -> Int
number_of_rows i = length i

number_of_columns :: [[Int]] -> Int
number_of_columns (x:xs) =  length x

consult :: (Int,Int) -> [[Int]] -> Int
consult (i,j) l = (l !! i) !! j

visited :: (Int,Int) -> [(Int,Int)] -> Bool
visited x y = elem x y

add :: (Int,Int) -> [(Int,Int)] -> [(Int,Int)]
add x y = x:y

visit :: (Int,Int) -> [(Int,Int)] -> [[Int]] -> Int -> [(Int,Int)]
visit (i,j) vis mat cond | move_right (i,j) mat cond && not (visited (i,j+1) vis) = visit (i,j+1) (add (i,j+1) vis) mat cond
               | move_down (i,j) mat cond && not (visited (i+1,j) vis) = visit (i+1,j) (add (i+1,j) vis) mat cond
               | move_left (i,j) mat cond && not (visited (i,j-1) vis) = visit (i,j-1) (add (i,j-1) vis) mat cond
               | move_up (i,j) mat cond && not (visited (i-1,j) vis) = visit (i-1,j) (add (i-1,j) vis) mat cond
               | otherwise = vis

move_right:：（Int，Int）->[[Int]]->Int->Bool
向右移动（i，j）mat cond |（j+1）<列数mat&&consult（i，j+1）mat/=cond=True
|否则=假
向左移动：：（Int，Int）->[[Int]]->Int->Bool
向左移动（i，j）mat cond |（j-1）>=0&&consult（i，j-1）mat/=cond=True
|否则=假
上移：：（Int，Int）->[[Int]]->Int->Bool
向上移动（i，j）mat cond |（i-1）>=0&&consult（i-1，j）mat/=cond=True
|否则=假
下移：：（Int，Int）->[[Int]]->Int->Bool
向下移动（i，j）mat cond（i+1）<行数mat&&consult（i+1，j）mat/=cond=True
|否则=假
imp:：（Int，Int）->Int
imp（i，j）=i
行数：[[Int]]->Int
_行数i=长度i
列数：：[[Int]]->Int
_列数（x:xs）=长度x
咨询：：（Int，Int）->[[Int]]->Int
参考（i，j）l=（l！！i）！！J
访问：：（Int，Int）->[（Int，Int）]->Bool
已访问x y=元素x y
加：：（Int，Int）->[（Int，Int）]->[（Int，Int）]
加x y=x:y
访问：：（Int，Int）->[（Int，Int）]->[[Int]]->Int->[（Int，Int）]
访问（i，j）相对于材料状态|向右移动（i，j）材料状态和不移动（访问（i，j+1）相对于）=访问（i，j+1）（添加（i，j+1）相对于材料状态
|下移（i，j）材料状态和未下移（参观（i+1，j）材料状态）=参观（i+1，j）（添加（i+1，j）材料状态
|向左移动（i，j）材料状态和未移动（访问（i，j-1）材料状态）=访问（i，j-1）（添加（i，j-1）材料状态
|向上移动（i，j）材料状态和未访问（i-1，j）材料状态=访问（i-1，j）（添加（i-1，j）材料状态
|否则=vis

在这里使用数组类型而不是列表列表是否有帮助？您仍然在进行函数式编程，只是使用了更好的数据结构

如果对您有效，您可以创建

数组（Int，Int）Int

。见：

---

…去图书馆。

我不认为回溯是你真正想要的。在我看来，您的目标是让

visit

函数建立一个访问列表，因为它从某个点查找矩阵中满足某个条件的所有连接元素。您需要考虑的是什么算法将实现这一点。不用担心用函数式或命令式编程来表达它。试想一下：算法本质上是递归的吗？迭代的？如果你在计算过程中停止它，你怎么知道在算法中接下来要做什么？您需要什么数据

---

我现在不担心代码中的各种改进（使用

Array

或删除

if

语句等），您可以稍后再讨论这些改进。你缺少的关键是一个可行的算法。

哪里是

0110；0 1 1 0; 0 0 0 0

？我不明白，第一个矩阵[[0 1 2 2][0 1 1 2][0 3 0]]的type-1区域不应该是[[0 1 2 2][0 1 1 2][0 0 0]]吗？是的，我最初发布时犯了一个错误。相邻区域的值应为n或>n。

import Data.Array