python--蓝桥杯--深搜DFS、广搜BFS

##深度优先搜索（DFS）
##深度优先搜索是一种枚举所有完整路径以遍历所有情况的搜索方法
##使用递归可以很好地实现深度优先搜索（系统栈）

def DFS(index):
    if index>=n:
        ## 进行相应处理
        return
    for i in range(index,n):
        ## 进行相应处理
        ##入栈
        
        ## 进入下一层递归
        DFS(index+1)

        ## 进行相应处理
        ## 出栈

    return


##广度优先搜索（BFS）
##广度优先搜索一般由队列实现，且总是按层序遍历
from collections import deque
def BFS(s):
    dq=deque()
    dq.append(s)
    while (len(dq)!=0):
        ## 取出队列首位元素top
        ## 访问队列首位元素top
        ## 将队首元素出队
        ## 将top下一层结点中未曾入队的结点全部入队，并设置为已入队

广搜BFS

给出一个矩阵n*m，矩阵中的元素为0/1。称位置（x,y）与其上下左右四个位置是相邻的。如果矩阵中有若干个1是相邻的（不必是俩俩相邻），那么称这些1构成一个块。求给定的矩阵中快的个数。

## 输入样例
6 7
0 1 1 1 0 0 1
0 0 1 0 0 0 0
0 0 0 0 1 0 0
0 0 0 1 1 1 0
1 1 1 0 1 0 0
1 1 1 1 0 0 0

from collections import deque

def judge(x,y):
    ## 判断越界
    if x>=n or x<0 or y>=m or y<0:
        return False
    ## 如果遍历的位置是0或该位置已经在队列中
    if matrix[x][y]==0 or inq[x][y]==True:
        return False
    ## 以上都不满足
    return True

def BFS(x,y):
    dq=deque()
    dq.append([x,y])
    inq[x][y]=True
    while len(dq)!=0:
        top=dq.popleft()
        for i in range(4):
            New_x=top[0]+X[i]
            New_y=top[1]+Y[i]
            if judge(New_x,New_y):
                dq.append([New_x,New_y])
                inq[New_x][New_y]=True

n,m=map(int,input().strip().split())
matrix=[list(map(int,input().strip().split())) for _ in range(n)]
inq=[[False]*m for _ in range(n)]
## 设置增量数组
## 方便遍历四个方向
X=[0,0,1,-1]
Y=[1,-1,0,0]
ans=0
for x in range(n):
    for y in range(m):
        if matrix[x][y]==1 and inq[x][y]==False:
            ans+=1
            BFS(x,y)
print(ans)

广搜BFS

给定一个n*m大小的迷宫，其中*代表不可通过的墙壁，而 . 代表平地，S表示起点，T代表终点。移动过程中，如果当前位置是（x,y）（下标从0开始），且每次只能前往上下左右四个平地，求从起点S到终点T的最小步数。

## 样例输入
5 5
.....
.*.*.
.*S*.
.***.
...T*

from collections import deque
def judge(x,y):
    if x>=n or x<0 or y>=m or y<0:
        return False
    if matrix[x][y]=="*" or inq[x][y]==True:
        return False
    return True

## 也可以定义一个结构体Node,存放x,y,step
## 代替[x,y,step]
def BFS(x,y,step):
    dq=deque()
    dq.append([x,y,step])
    while (len(dq)!=0):
        top=dq.popleft()
        if matrix[top[0]][top[1]]=="T":
            return top[2]
        for i in range(4):
            New_x=top[0]+X[i]
            New_y=top[1]+Y[i]
            New_step=top[2]+1
            if judge(New_x,New_y):
                dq.append([New_x,New_y,New_step])
                inq[New_x][New_y]=True
    return -1
def find_S(matrix):
    for i in range(n):
        for j in range(m):
            if matrix[i][j]=="S":
                return i,j
            
n,m=map(int,input().strip().split())
matrix=[list(input()) for _ in range(n)]
inq=[[False]*m for _ in range(n)]
X=[0,0,1,-1]
Y=[1,-1,0,0]
x,y=find_S(matrix)
step=BFS(x,y,0)
print(step)

## 结构体
class Node:
    def __init__(self, x=None, y=None, step=None):
        self.x = x
        self.y = y
        self.step= step


root=Node()
root.x=...
root.y=...
root.step=...