通过矩阵查找所有路线

Question

虽然我有一个如下矩阵，但从左上角查找所有路径，直到得到“0”。 'D' 代表底部元素是跟踪的下一步。 “R”代表正确的元素。 'B' 代表底部和右侧元素都是可选的。 'C' 代表右下角的元素。

[['R' 'C' 'D' 'B' 'D' 'C' '0']
 ['C' 'B' 'C' 'B' 'D' 'D' '0']
 ['B' 'D' 'B' 'B' 'C' 'D' '0']
 ['R' 'C' 'B' 'D' 'B' 'C' '0']
 ['B' 'B' 'R' 'C' 'B' 'D' '0']
 ['R' 'C' 'B' 'R' 'R' 'C' '0']
 ['C' 'R' 'C' 'B' 'B' 'B' '0']
 ['0' '0' '0' '0' '0' '0' '0']]

在这种情况下，有两条路径满足要求，分别是

(0, 0)R(0, 1)C(1, 2)C(2, 3)B(2, 4)C(3, 5)C(4, 6)0
(0, 0)R(0, 1)C(1, 2)C(2, 3)B(3, 3)D(4, 3)C(5, 4)R(5, 5)C(6, 6)0

我尝试使用递归函数来查找这两条路径中的所有“C”， 由于 (2, 3)B 中存在 fork，因此该函数仅在joint 之后完全返回其中一条路径。

(5, 5)C(4, 3)C
(3, 5)C(2, 4)C(1, 2)C(0, 1)C

那么我怎样才能修改我的代码以获得完整的结果呢？

def printC(matrix, i=0, j=0):
    if matrix[i][j] == '0':
        print()
        return None
    elif matrix[i][j] == 'B':
        printC(matrix, i+1, j)
        printC(matrix, i, j+1)
    elif matrix[i][j] == 'D':
        printC(matrix, i+1, j)
    elif matrix[i][j] == 'R':
        printC(matrix, i, j+1)
    elif matrix[i][j] == 'C':
        printC(matrix, i+1, j+1)
        print((i,j), end='')
        print(matrix[i][j], end='')

printC(matrix)
print()

谢谢

Answer 1

解决这个问题的自然算法是backtracking：

• 继续前进，在所有选项中选择第一个选项
• 到达终点后，返回（回溯）并选择下一个选项；如果没有更多可用选项，请进一步返回
• 从初始元素回溯后，您已用尽所有路线。

你在两种情况下“走到了尽头”：

• 您点击了0 => 将当前路线添加到结果中
• 您碰到了一个已经在路线中的元素——即有一个循环。
  • 根据您的规则，这是不可能的：一步总是向下、向右或两者兼而有之。所以我们不必担心这个。

---

要跟踪进度，我们需要：

• 当前坐标
  • 整数

• 当前路由，能够追加到末尾并从末尾弹出（即stack）。我们还需要存储最后做出的选择。

  • Python list 支持这个：

    route = []
    # go forward
    route.append((new_x,new_ym,choice))
    # backtrack
    route.pop()
    x,y,last_choice = route[-1]
    

• 找到的路线序列，可以附加到末尾

  • 再次，list：

    results=[]
    # add result
    results.append(tuple(step[:2] for step in route))    # don't need choices in result
    

完整的程序看起来像这样（伪代码）：

initialization
while True:
    if can_step_forward:
        make_step_with_the_next_choice
        if hit_0:
            add_result
    else:
        backtrack
        if backtracked_past_the_beginning:
            break

return result

使用所有这些，您现在可以将解决方案放在一起吗？

Answer 2

我认为这可能更接近你想要的：

def printC(matrix, i=0, j=0, previous=None):
    if not previous:
        previous = []
    if matrix[i][j] == '0':
        print()
        return None
    elif matrix[i][j] == 'B':
        previous_branch = previous[:]
        printC(matrix, i+1, j, previous)
        print(''.join(reversed(previous_branch)), end='')
        printC(matrix, i, j+1, previous)
    elif matrix[i][j] == 'D':
        printC(matrix, i+1, j, previous)
    elif matrix[i][j] == 'R':
        printC(matrix, i, j+1, previous)
    elif matrix[i][j] == 'C':
        previous.append('{}{}'.format((i,j), matrix[i][j]))
        printC(matrix, i+1, j+1, previous)
        print((i,j), end='')
        print(matrix[i][j], end='')

诀窍是存储以前的命令，然后在遍历另一个分支时重新启动它们。之所以必须反转它们，是因为您在递归中选择的回溯方法会在采用路径后打印命令，这意味着首先打印最新的命令，因为它首先被解析，等等。

不幸的是，由于递归方法，代码有点复杂；在这种情况下，我实际上认为迭代方法更适合。

编辑：这是一种迭代方法，但我必须注意嵌套列表可能不是最好的树替代：

def printC(matrix, i=0, j=0):
    trace_root = [(i, j)]
    current_trace = trace_root
    trace_waiting = []
    while True:
        if matrix[i][j] == '0':
            if trace_waiting:
                current_trace = trace_waiting.pop()
                i, j = current_trace[-1]
            else:
                break
        elif matrix[i][j] == 'B':
            current_trace.extend([[(i+1, j)], [(i, j+1)]])
            trace_waiting.append(current_trace[-1])
            current_trace = current_trace[-2]
            i, j = current_trace[-1]
        else
            if matrix[i][j] == 'D':
                i += 1
            elif matrix[i][j] == 'R':
                j += 1
            elif matrix[i][j] == 'C':
                i, j = i+1, j+1
            current_trace.append((i,j))
    return trace_root