目录
推荐资源：
- OI Wiki - OI Wiki (oi-wiki.org)
- 内容有算法、数据结构、数学知识、编程语言等等
- 是一个免费开放且持续更新的 编程竞赛 知识整合站点
BFS(Breadth First Search)
广度优先搜索（BFS）是一种用于图和树数据结构的搜索算法。它从图或树的根节点开始，逐层地向下搜索，并在同一层节点中完成搜索后再向下一层节点进行搜索。它通常使用队列来实现，在搜索过程中，将当前节点的邻居节点依次加入队列中，以确保按照层级顺序进行搜索。
代码模板
//... /** * 进行广度优先搜索 * @param u 起始节点 */ void bfs(int u) { while (!Q.empty()) Q.pop(); // 清空队列Q Q.push(u); // 将u加入队列Q visited[u] = 1; // 标记节点u已访问 distance[u] = 0; // 节点u到起始节点的距离为0 previous[u] = -1; // 节点u的父节点为-1 while (!Q.empty()) { u = Q.front(); // 取出队首节点u Q.pop(); // 弹出队首节点u for (int i = head[u]; i; i = e[i].nxt) { // 遍历u的相邻节点 if (!visited[e[i].to]) { // 如果相邻节点未被访问 Q.push(e[i].to); // 将相邻节点加入队列Q visited[e[i].to] = 1; // 标记相邻节点已访问 distance[e[i].to] = distance[u] + 1; // 更新相邻节点到起始节点的距离 previous[e[i].to] = u; // 更新相邻节点的父节点为u } } } } /** * 根据父节点数组p还原路径并输出 * @param x 终点节点 */ void restore(int x) { vector<int> restore; // 用于存储路径节点 for (int v = x; v != -1; v = previous[v]) { // 从终点节点开始回溯路径 restore.push_back(v); // 将节点v加入路径 } std::reverse(restore.begin(), restore.end()); // 反转路径节点，得到正序路径 for (int i = 0; i < restore.size(); ++i) printf("%d", restore[i]); // 输出路径节点 puts(""); // 输出换行符 } //... //我们用一个队列 Q 来记录要处理的节点，然后开一个布尔数组 visited[] 来标记是否已经访问过某个节点。 //开始的时候，我们将所有节点的 visited 值设为 0，表示没有访问过；然后把起点 s 放入队列 Q 中并将 visited[s] 设为 1。 //之后，我们每次从队列 Q 中取出队首的节点 u，然后把与 u 相邻的所有节点 v 标记为已访问过并放入队列 Q。 //循环直至当队列 Q 为空，表示 BFS 结束。BFS 的知识点包括：
- 图的表示方法：邻接表、邻接矩阵等
- 队列：BFS 使用队列来记录待访问的节点
- 标记已访问节点：防止重复访问相同节点
- 图的遍历顺序：BFS 的遍历顺序是按层次进行的
- 状态搜索：在有向无环图中，BFS 可以用于搜索从起始状态到目标状态的路径
- BFS常用于寻找图中的最短路径、检查图中是否存在特定节点或寻找所有可能的路径等问题。BFS 也可以应用于解决迷宫问题、状态空间搜索等具体的应用场景中。
一、跳马
一个8×8的棋盘上有一个马初始位置为(a,b)，他想跳到(c,d)，问是否可以？如果可以，最少要跳几步？
分析：
- 如果同一层都访问完了，再访问下一层，
- 在步数存储在map数组中，每处理完一层，存储在队列中的该层结点的步数 = 上层的步数 + 1
- 访问map数组中终点坐标的值，返回即可
package no1_1;
import java.util.*;
public class Main {
static int dir[][]= {{-2,-1},{-2,1},{-1,-2},{-1,2},{1,2},{1,-2},{2,1},{2,-1}};//定义8个方向马可以走的相对坐标
//大小设置成15*15，是为了容纳8x8的棋盘以及边界外的一圈缓冲区。这样可以确保在搜索过程中不会越界访问到数组map的位置
static int map[][]=new int[15][15];//记录步数
static int x,y,targetX,targetY;//定义马的起点和终点坐标
static int vis[][]=new int[15][15];//记录走过的坐标
//坐标类，用于表示马的坐标
public static class Node{
int x;
int y;
//构造函数
public Node(int x,int y) {
this.x=x;
this.y=y;
}
//获取横坐标
public int getX() {
return x;
}
//获取纵坐标
public int getY() {
return y;
}
}
//主函数
public static void main(String[] args) {
Scanner input=new Scanner(System.in);
int a=input.nextInt();//起点横坐标
int b=input.nextInt();//起点纵坐标
int c=input.nextInt();//终点横坐标
int d=input.nextInt();//终点纵坐标
bfs(a,b);//进行广度优先搜索
System.out.println(map[c][d]);//输出到达终点的最少步数
}
//判断马是否在棋盘上
public static boolean inmap(int x,int y) {
return x>=1 && x<=8 && y>=1 && y<=8;//判断横纵坐标是否在1-8范围内
}
//广度优先搜索
public static void bfs(int x,int y) {
vis[x][y]=1;//标记起点已走过
Queue<Node> queue = new LinkedList<>();//创建队列
queue.add(new Node(x,y));//将起点加入队列
map[x][y]=0;//起点步数为0
while(!queue.isEmpty()) {//队列不为空时循环
Node now=queue.poll();//获取队首元素，并移除队首元素
for(int i=0;i<8;i++) {//遍历8个方向
int nextX=now.x+dir[i][0];//计算下一个横坐标
int nextY=now.y+dir[i][1];//计算下一个纵坐标
if(inmap(nextX,nextY) && vis[nextX][nextY]==0) {//判断下一个点是否在棋盘上且未走过
vis[nextX][nextY]=1;//标记下一个点已走过
map[nextX][nextY]=map[now.x][now.y]+1;//计算步数
queue.add(new Node(nextX,nextY));//将下一个点加入队列
}
}
}
}
}
二、勇士和地雷阵
分析：
- 使用BFS求地雷阵中除地雷外从左上角为起点到达其他点的最少步数，保存在原数组，省点内存
- 然后根据士兵的坐标，查找原数组里的值 ，若 若<=士兵的最大步数，即为可行
bfs()方法为计算地雷阵各点的步数，只调用一次，而success()方法为判断该士兵是否能出去，调用次数为士兵的个数
注意：
有些士兵被地雷包围，从（0，0）点开始是无法到达该点，计算步数的
有些士兵直接位于终点
package no1_1;
import java.io.*;
import java.util.*;
public class Main {
static int n;
static int[][] minefield;
public static void main(String[] args) throws IOException {
BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
n=Integer.parseInt(reader.readLine());
minefield=new int[n][n];
for(int i=0;i<n;i++) {//地雷阵，0表示无地雷，Integer.MAX_VALUE表示有地雷
String s=reader.readLine();
for(int j=0;j<n;j++) {
if(s.charAt(j)=='-') {
minefield[i][j]=0;
}else {
minefield[i][j]=Integer.MAX_VALUE;
}
}
}
bfs();//使用BFS计算起点到各点的最短距离
String string;
while((string=reader.readLine())!=null) {
String[] s=string.split(" ");
int x=Integer.parseInt(s[0]);
int y=Integer.parseInt(s[1]);
int step=Integer.parseInt(s[2]);
System.out.println(success(x,y,step));
}
}
//计算起点(0,0)到地图各点的最短距离，保存在minefield数组中
public static void bfs() {
int[] dx= {0,0,1,-1};
int[] dy= {1,-1,0,0};//(dx,dy)表示x,y方向上的增量，分别为向上，向下，向右，向左
Queue<int[]> queue=new LinkedList<>();//存储待处理的点的坐标
boolean[][] visited=new boolean[n][n];
queue.offer(new int[] {0,0});//添加起点
visited[0][0]=true;//标记该点
//从(x,y)点跳到(newX,newY)点，(newX,newY)点有四种可能，遍历这四种可能，
//从(0,0)到(newX,newY)的步数就等于从(0,0)点到达(x,y)的最少步数再加一
while(!queue.isEmpty()) {
int[] current=queue.poll();
int x=current[0],y=current[1];
for(int i=0;i<4;i++) {//遍历四个方向
int newX=x+dx[i];
int newY=y+dy[i];
if(newX >= 0 && newX < n && newY >= 0 && newY < n
&& !visited[newX][newY] && minefield[newX][newY] != Integer.MAX_VALUE) {
queue.offer(new int[] {newX,newY});
visited[newX][newY]=true;//标记该点
minefield[newX][newY]=minefield[x][y]+1;//步数加一
}
}
}
}
//查询当前坐标到达（0，0）点的最少步数
public static int success(int x,int y,int step) {
if(x==0 && y==0) {//就位于起点
return 1;
}else if(minefield[x][y]<=step && minefield[x][y]>0) {//minefield[x][y]>0是为了避免有些坐标被地雷包围，无法到达的情况
return 1;
}else {
return -1;
}
}
}
8746
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
