【模板】BFS

#include <stdio.h>  
#include <string.h>  
#include <queue>  
using namespace std;  
  
struct node  
{  
    int x,y,step;  
};  
  
char map[105][105];  
int vis[105][105];  
int to[4][2]= {1,0,-1,0,0,1,0,-1};  
int n,m,sx,sy,ex,ey,ans;  
  
int check(int x,int y)  
{  
    if(x<0 || x>=n || y<0 || y>=m)  
        return 1;  
    if(vis[x][y] || map[x][y]=='#')  
        return 1;  
    return 0;  
}  
  
void bfs()  
{  
    int i;  
    queue<node> Q;  
    node a,next;  
    a.x = sx;  
    a.y = sy;  
    a.step = 0;  
    vis[a.x][a.y]=1;  
    Q.push(a);  
    while(!Q.empty())  
    {  
        a = Q.front();  
        Q.pop();  
        if(map[a.x][a.y]=='E')  
        {  
            ans = a.step;  
            return ;  
        }  
        for(i = 0; i<4; i++)  
        {  
            next = a;  
            next.x+=to[i][0];  
            next.y+=to[i][1];  
            if(check(next.x,next.y))  
                continue;  
            next.step=a.step+1;  
            vis[next.x][next.y] = 1;  
            Q.push(next);  
        }  
    }  
    ans = -1;  
}  
  
int main()  
{  
    int t;  
    scanf("%d",&t);  
    while(t--)  
    {  
        scanf("%d%d",&n,&m);  
        int i,j;  
        for(i = 0; i<n; i++)  
            scanf("%s",map[i]);  
        for(i = 0; i<n; i++)  
        {  
            for(j = 0; j<m; j++)  
            {  
                if(map[i][j]=='S')  
                {  
                    sx = i;  
                    sy = j;  
                }  
            }  
        }  
        memset(vis,0,sizeof(vis));  
        bfs();  
        printf("%d\n",ans);  
    }  
  
    return 0;  
}  

<think>嗯,用户想找DFS和BFS的实现模板。首先得确定他们需要的是基础的代码结构,可能是在准备面试或者学习算法。我需要先回忆一下这两种算法的基本框架。DFS通常用递归或者栈,而BFS用队列。根据用户提供的引用,比如引用[3]提到BFS的框架是起始点入队,循环处理队列,扩展队头元素。而DFS的话,引用[1]和[2]都提到DFS会尽可能深入,用递归或栈实现。 用户给的引用中有几个关键点,比如BFS的空间消耗较大,而DFS可能更节省空间但时间上可能有劣势。这些点可能在模板中体现出来。比如BFS需要用队列保存每一层的节点,而DFS递归时的隐式栈或者显式栈的结构。 需要确保模板代码正确,比如DFS的递归版本和迭代版本,BFS的标准队列操作。同时要注意注释说明,让用户明白每个步骤的作用。例如,在BFS模板中,是否需要标记已访问的节点?是的,特别是处理图的时候,避免重复访问。 然后,用户可能还需要一些注意事项,比如DFS在路径查找时的回溯步骤,或者BFS如何记录层数。引用[2]提到剪枝的重要性,这可能需要在模板之外进行优化,但模板本身应该保持简洁。 还要考虑不同应用场景下的变种,比如是否处理树或图的结构。例如,树的DFS可能不需要标记访问,但图的DFS必须标记,避免循环。因此,在模板中可能需要包含visited集合的部分。 最后,根据用户的要求,生成相关问题。可能需要围绕模板的使用、性能比较、应用场景来提问。例如,如何选择DFS和BFS,或者它们的时空复杂度分析。 总结下来,回答需要提供清晰的代码模板,区分递归和迭代实现,注明关键步骤,并附上相关问题帮助用户深入理解。</think>### DFS与BFS算法模板代码解析 #### 1. 深度优先搜索(DFS)模板 DFS通过递归或栈实现“深度优先”特性,适用于路径查找、连通性检测等场景[^1]。 **递归实现模板**(以二叉树为例): ```python def dfs(node): if node is None: # 终止条件 return # 处理当前节点(例如打印或记录路径) print(node.val) # 递归访问相邻节点 dfs(node.left) dfs(node.right) ``` **迭代实现模板**(显式栈): ```python def dfs_iterative(root): stack = [root] visited = set() # 用于图结构防重复访问 while stack: node = stack.pop() if node not in visited: visited.add(node) # 处理当前节点 print(node.val) # 将子节点按反向顺序入栈(保证顺序正确) if node.right: stack.append(node.right) if node.left: stack.append(node.left) ``` #### 2. 广度优先搜索(BFS模板 BFS通过队列实现“逐层扩展”特性,适用于最短路径、层级遍历等问题[^3]。 **标准模板代码**: ```python from collections import deque def bfs(root): queue = deque([root]) visited = set() # 用于图结构防重复访问 while queue: level_size = len(queue) for _ in range(level_size): # 按层处理(可选) node = queue.popleft() if node not in visited: visited.add(node) # 处理当前节点 print(node.val) # 将相邻节点加入队列 if node.left: queue.append(node.left) if node.right: queue.append(node.right) ``` #### 关键对比 | 特性 | DFS | BFS | |-----------|-------------------|-------------------| | 数据结构 | 栈(递归隐式栈/显式栈) | 队列 | | 空间复杂度 | $O(h)$(树的高度) | $O(w)$(树的宽度) | | 适用场景 | 路径存在性、拓扑排序 | 最短路径、层级遍历 |
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值