回溯法

使用回溯算法从矩阵中找到指定字符串

字符矩阵：

$$\begin{equation*} \begin{bmatrix} a&b&t&g\\ c&f&e&s\\ j&d&e&h \end{bmatrix} \end{equation*}$$
目标字符串为 bfce 和 abfb

算法思想

• 随便从矩阵中找到一个位置，然后查看该位置的元素是不是目标字符串的第一个元素，标记当前位置为已经访问，当前位置为搜索位置。
• 在当前位置的上下左右找可能的位置，获取位置的元素，标记为已经访问，如果找到元素，搜索位置设置为当前位置，否则查看下一个位置，如果上下左右都不存在，函数退回到上层调用的位置，继续接招查找。直到找到目标元素的最后一个元素时，确认找到，将路径输出。

代码实现

• 该代码并不是随机给定一个位置开始查找，而是找到和目标字符串第一个字符相同的元素的位置。如果连第一个元素都找不到，则肯定找不到（代码中并没有如此反映可以加入find_start找到的判断是否开始查找）。

class matrix_str(object):
    def __init__(self,target="bfce",matrix_string=['a','b','t','g','c','f','c','s','j','d','e','h'],col=4,row=3):
        self.target = target
        self.col = col
        self.row = row
        self.matrix_string = matrix_string
        self.visited = [0]*len(matrix_string)
        self.paths = []
    def next_pos(self,pos):
        x = pos[0]
        y = pos[1]
        maybe_path = []
        x_left = x-1
        x_right = x+1
        y_up = y-1
        y_down = y+1
        maybe_path.append([x_left, y])
        maybe_path.append([x_right, y])
        maybe_path.append([x, y_up])
        maybe_path.append([x, y_down])
        for i in maybe_path:
            if i[0]<0 or i[0]>self.row-1 or i[1]<0 or i[1]>self.col-1:
                maybe_path.remove(i)
        return maybe_path
    # 设置该位置被访问过
    def set_visited(self,pos):
        self.visited[pos[0]*self.row+pos[1]] = 1
    # 获取指定位置的值
    def get_current_value(self,current):
        return self.matrix_string[current[0]*self.col+current[1]]
    def visted_value(self,pos):
        return self.visited[pos[0]*self.col+pos[1]]
    def find_start(self):
        for i in range(self.row):
            for j in range(self.col):
                if self.matrix_string[i*self.row+j] == self.target[0]:
                    return [i,j]
    def search(self,current_pos,index):
        num = len(self.target)
        self.set_visited(current_pos)
        # print("str:{}".format(self.get_current_value(current_pos)))
        next_pos = self.next_pos(current_pos)
        self.paths.append(current_pos)
        if index<num:
            for n in next_pos:
                if self.get_current_value(n) == self.target[index] and self.visted_value(n) == 0:
                    current_pos = n
                    self.search(current_pos,index+1)
                else:
                    self.set_visited(n)
                    continue
            self.paths.pop(-1)
        else:
            print("字符串找到")
            print("路径：{}".format(self.paths))





def main():
    m = matrix_str()
    pos = [[0,0],[0,1],[0,2],[0,3],[1,0],[1,1],[1,2],[1,3]]
    # for i in pos:
    #     print("当前节点位置:{},下一步节点位置:{}".format(i,m.next_pos(i)))
    # for i in range(3):
    #     for j in range(4):
    #         print("pos:{},value:{}".format([i,j],m.get_current_value([i,j])))
    # print("start point:{},value:{}".format(m.find_start(),m.get_current_value(m.find_start())))
    start_pos = m.find_start()
    # print("start point:{}".format(start_pos))
    m.search(start_pos,index = 1)
if __name__ == "__main__":
    main()