蓝桥杯迷宫（bfs）

迷宫（bfs）

单向搜索（部分超时）

from queue import *
# 判断九宫格是否出界限
def check(x,y):
    return x<3 and x>=0 and y<3 and y>=0
# 将数组转换为字符串
def toString():
    global m
    l = ''
    for i in range(3):
        for j in range(3):
            l +=m[i][j]
    return l

# 将字符串转换为数组
def toMatrix(strn):
    global m
    # 定义二维数组
    for i in range(len(strn)):
        m[i//3][i%3]=strn[i]

first = input().strip()
last = input().strip()
m = [['0' for j in range(3)]for i in range(3)]
dx=[0,0,1,-1]
dy=[1,-1,0,0]
vis=[]
q=Queue()
ans=0x3f3f3f3f
def bfs(n,num):
    global m
    toMatrix(n)

    global last
    global ans
    
    q.put((n,num))
    vis.append(n)
    while not q.empty():
        a=q.get()


        if a[0]==last:
            if a[1]<ans:
                ans=a[1]
            return 

        toMatrix(a[0])
        for i in range(3):
            for j in range(3):
                if m[i][j]=='.':
                    x=i
                    y=j
        for i in range(4):
            x1=x+dx[i]
            y1=y+dy[i]
            if check(x1,y1):
                m[x][y],m[x1][y1] = m[x1][y1],m[x][y]
                # 将数组转换为字符串
                b= toString()
                if b not in vis:
                    vis.append(b)
                    q.put((b,a[1]+1))
                m[x][y],m[x1][y1] = m[x1][y1],m[x][y]







bfs(first,0)
if ans==0x3f3f3f3f:
    print(-1)
else:
    print(ans)

双向搜索

# 判断九宫格是否出界限
def check(x,y):
    return x<3 and x>=0 and y<3 and y>=0
# 将数组转换为字符串
def toString():
    global m
    l = ''
    for i in range(3):
        for j in range(3):
            l +=m[i][j]
    return l

# 将字符串转换为数组
def toMatrix(strn):
    global m
    # 定义二维数组
    m = [[None]*3 for i in range(3)]
    for i in range(len(strn)):
        m[i//3][i%3]=strn[i]

def doublebfs(first,last):
    global m
    dira = [[0,1],[0,-1],[1,0],[-1,0]] # 用来记录方向
    q1 = []
    q2 = []
    dis = {}  # 开始查找的点到当前点的一个距离
    vis = {}  # 访问标记 q1访问过的点标记为1 q2访问过的点标记为2
    q1.append(first)
    dis[first]=1
    vis[first]=1
    q2.append(last)
    dis[last]=1
    vis[last]=2
    while len(q1)>0 and len(q2)>0: # 如果其中一个队列为空，还没有找到解，说明无解
        if len(q1)<len(q2):  # 根据队列的容量来判断从哪一端开始查找，谁少谁先出列
            str1 = q1.pop(0)
            flag =1
        else:
            str1 = q2.pop(0)
            flag=2
        toMatrix(str1) # 将字符串转换为数组

        # 找到.的位置
        for i in range(3):
            for j in range(3):
                if m[i][j]=='.':
                    x=i
                    y=j

        # 从四个方向开始探测
        for i in range(4):
            tx = x + dira[i][0]
            ty = y + dira[i][1]
            # 判断是否出界
            if check(tx,ty):
                # 没有出界就探测
                m[x][y],m[tx][ty] = m[tx][ty],m[x][y]
                # 将数组转换为字符串
                str2 = toString()
                if not str2 in dis.keys(): # 如果这个点还没有被访问过 就标记
                    dis[str2] = dis[str1]+1
                    vis[str2] = vis[str1] # q1=1 q2=2 这样写可以避免判断是从那一端开始查找str2
                    # 如果刚开始是从q1从pop出来就push到p1
                    if flag==1:
                        q1.append(str2)
                    elif flag==2:
                        q2.append(str2)
                else: # 如果已经访问过就判断标记是否重合
                    if vis[str1]+vis[str2]==3:
                        ans = dis[str1]+dis[str2]-1 # 因为刚开始dis=1
                        return ans
                # 回溯 重新探测
                m[x][y], m[tx][ty] = m[tx][ty], m[x][y]
    return -1 # 找不到
first = input().strip()
last = input().strip()
if last == first:
    print('0')
else:
    print(doublebfs(first,last))