走迷宫

from collections import deque
class Maze:
    def __init__(self):
        self.n, self.m = list(map(int, input().split(" ")))
        self.start_y, self.start_x, self.end_y, self.end_x = list(
            map(lambda x: int(x)-1, input().split(" ")))
        self.grid = [['\0' for _ in range(self.m)]
                     for _ in range(self.n)]
        for i in range(self.n):
            self.grid[i] = list(str(input()))
        self.visited = [[False for _ in range(self.m)]
                        for _ in range(self.n)]
        self.direction = [(1, 0), (0, 1), (-1, 0), (0, -1)]
    def bfs(self):
        queue = deque([(self.start_x, self.start_y, 0)])
        while queue:
            curr_x, curr_y, curr_len = queue.popleft()
            if self.visited[curr_y][curr_x]:
                continue
            self.visited[curr_y][curr_x] = True
            if (curr_y, curr_x) == (self.end_y, self.end_x):
                return curr_len
            for dx, dy in self.direction:
                nx = curr_x + dx
                ny = curr_y + dy
                if ((0 <= nx < self.m) and
                    (0 <= ny < self.n) and
                        self.grid[ny][nx] == "." and
                        not self.visited[ny][nx]):
                    nl = curr_len+1
                    queue.append((nx, ny, nl))
        return -1
if __name__ == "__main__":
    m = Maze()
    print(m.bfs())

from collections import deque

n,m = map(int , input().split())
xs,ys,xt,yt = map(int, input().split())
xs,ys,xt,yt = xs-1,ys-1,xt-1,yt-1
maze = []
for _ in range(n):
    row = list(input())
    maze.append(row)

def play_maze(n,m,xs,ys,xt,yt,maze):
    visited= [[False]*m for _ in range(n)]
    visited[xs][ys]=True
    q = deque()
    q.append((xs,ys,0)) # x,y,steps
    directions = [(1,0),(-1,0),(0,1),(0,-1)]
    while q:
        x,y,steps = q.popleft()
        if (x,y)==(xt,yt):
            return steps
        for dx,dy in directions:
            nx ,ny = x+dx, y+dy
            if 0<=nx<n and 0<=ny<m and maze[nx][ny]=='.' and not visited[nx][ny]:
                visited[nx][ny]=True
                # 注意这里不能写steps +=1,再append(steps),会导致不同方向之间的初始steps会不同
                q.append((nx,ny,steps+1))
    return -1

print(play_maze(n,m,xs,ys,xt,yt,maze)) 

import sys
from collections import deque


def main():
    n, m = map(int, sys.stdin.readline().split())
    xs, ys, xt, yt = map(int, sys.stdin.readline().split())
    grid = [sys.stdin.readline().strip() for _ in range(n)]

    # 转换为 0-based 或保持 1-based，根据题目要求调整
    xs -= 1
    ys -= 1
    xt -= 1
    yt -= 1

    if grid[xs][ys] == "*"&nbs***bsp;grid[xt][yt] == "*":
        print(-1)
        return

    directions = [(-1, 0), (1, 0), (0, -1), (0, 1)]
    visited = [[-1 for _ in range(m)] for __ in range(n)]
    q = deque()
    q.append((xs, ys))
    visited[xs][ys] = 0

    while q:
        x, y = q.popleft()
        if x == xt and y == yt:
            print(visited[x][y])
            return
        for dx, dy in directions:
            nx, ny = x + dx, y + dy
            if (
                0 <= nx < n
                and 0 <= ny < m
                and grid[nx][ny] == "."
                and visited[nx][ny] == -1
            ):
                visited[nx][ny] = visited[x][y] + 1
                q.append((nx, ny))

    print(-1)


if __name__ == "__main__":
    main()

from copy import copy
import copy
def bfs(a1,b1,a2,b2,pathmap):
    queue=[[a1,b1]]
    step=0
    while queue:
        queue1=[]
        for item in queue:
            for i, j in [[0, 1], [0, -1], [1, 0], [-1, 0]]:
                if (0<=item[0]+i<=len(pathmap)-1)&(0<=item[1]+j<=len(pathmap[0])-1):
                    a=item[0]+i;b=item[1]+j
                    if (pathmap[a][b]!=1)&(pathmap[a][b]!=-1):
                        queue1.append([a,b])
                        pathmap[a][b]=1
                    if (a==a2)&(b==b2):
                        return step+1

        step+=1
        queue=copy.deepcopy(queue1)
    return -1

n,m=map(int,input().split())
a1,b1,a2,b2=map(int,input().split())
map=[]
for _ in range(n):
    map.append(list(input()))
pathmap=[]
for i in range(n):
    temp=[]
    for j in range(m):
        if map[i][j]=='.':
            temp.append(0)
        else:
            temp.append(-1)
    pathmap.append(temp)

if (pathmap[a2-1][b2-1]==-1)|(pathmap[a1-1][b1-1]==-1):
    short=-1
else:
    pathmap[a1 - 1][b1 - 1] = 1
    short=bfs(a1-1,b1-1,a2-1,b2-1,pathmap)
print(short)