BFS－基础简单的算法
前言
有时候，当你并不了解很多高级算法的时候，搜索不失为一种解决问题的好方法，而且很多高级算法有或多或少的会用到搜索或者搜索的思想。可见，搜索是一个基础并且必须要掌握的算法。
在这篇文章中，会对BFS进行一次系统的总结。好了，废话不多说，赶紧开始。
搜索里面包含了一下内容：
- 列表
- 线性搜索
- 二分搜索
- 树/图
- 广度优先搜索
- 最良优先搜索
- 均一开销搜索
- A*算法
- 深度优先搜索
- 迭代深化深度优先搜索
- 深度限制搜索
- 双方向探索
- 分支限定法
- 广度优先搜索
- 字符串
- KMP算法
- BM算法
- AC自动机
- Rabin-Karp算法
- 位图算法
但是这里直讲关于BFS的内容，涉及到BFS的有树和图；
实现
树
注意，树里面分为二叉树和多叉树，处理方式有些不一样。
树的结构
/**
* 树
*/
struct TreeNode {
int val;
TreeNode *left;
TreeNode *right;
TreeNode *prev;
TreeNode(int x) : val(x), left(NULL), right(NULL), prev(NULL) {}
};
struct MoreTreeNode {
int val;
std::vector<MoreTreeNode*> nexts;
MoreTreeNode(int x) : val(x) {}
};
树的bfs实现
/**
* 树的最基本的BFS
* @param root
*/
void Solution::DanXiangTreeBFS(TreeNode* root) {
if (root == NULL) {
return ;
}
std::queue<TreeNode*> queues;
queues.push(root);
while (!queues.empty()) {
TreeNode* node = queues.front();
queues.pop();
std::cout << "value:" << node->val << std::endl;
if (node->left) {
queues.push(node->left);
}
if (node->right) {
queues.push(node->right);
}
}
}
/**
* 多插树的最基本的BFS
* @param root
*/
void Solution::MoreTreeBFS(MoreTreeNode* root) {
if (root) {
return ;
}
std::queue<MoreTreeNode*> queues;
queues.push(root);
std::unordered_map<MoreTreeNode*, bool> visited;
visited[root] = true;
while (!queues.empty()) {
MoreTreeNode* node = queues.front();
queues.pop();
// 访问所有子结点
for (int i = 0; i < node->nexts.size(); i++) {
MoreTreeNode* next = node->nexts[i];
if (next && !visited[next]) {
visited[next] = true;
std::cout << "value:" << next->val << std::endl;
queues.push(next);
}
}
}
}
总结
有没有发现，树的BFS遍历必然会存在一个队列，一个纪录是否访问过该结点的数组，总而言之，就是如果没访问过就加入，一直循环直到全部结点访问完。
图
图的表示方式有好几种，这里只用了邻接表的表达方式。
图的结构
/**
* 图
*/
// 图的最大顶点数目
#define MaxGraphSize 10
// 定义边表结点
struct ArcNode {
int val;
ArcNode* next;
};
// 定义顶点表结点
template <class T>
struct VertexNode {
T vertex;
ArcNode* firstNode;
};
// 图
struct Graph {
int edgeNum;
int vertexNum;
VertexNode<int> vertes[MaxGraphSize];
};
图的bfs实现
/**
* 图的BFS
*/
void Solution::GraphBFS(Graph* graph) {
int value[MaxGraphSize];
int head = 0, rear = 0;
int queue[MaxGraphSize];
int visited[MaxGraphSize];
memset(visited, 0, sizeof(int)*MaxGraphSize);
// 遍历所有的结点，并且以该结点作为起始点，迭代遍历起始结点的下一个结点
for (int i = 0; i < graph->vertexNum; i++) {
if (!visited[i]) {
visited[i] = 1;
queue[rear++] = i; //结点i入队列
}
while(head != rear) {
int j = queue[head++]; //结点j出队列
ArcNode* node = graph->vertes[j].firstNode; //找到对应的起始结点
while (node != NULL) {
int k = node->val; //结点k
if (!visited[k]) {
visited[k] = 1;
queue[rear++] = k;
}
node = node->next;
}
}
}
}
总结
是不是感觉有些不一样了呢，nono，实质还是一样的，只不过这里并没有用到stl，而是用下标head和rear去纪录出度和入度，实现一个队列，因为当head和rear相等的时候就是访问完所有结点的时候。
双向广搜
什么是双向广搜呢，就是说使用两个队列，一个从头用BFS搜，另一个从尾也用BFS搜，直到双方存在重叠的结点，则返回，至于返回什么根据题目的要求，可以是层数balabala；因为将搜索分为两个部分，搜索的时间自然会变得很快。
/**
* 双向广搜，存在两个方向上的BFS，当两个方向的搜索生成同一子结点时终止此搜索
* 通常存在两种方法：1.两个方向交替扩展，2.选择结点个数较少的那个方向先扩展
* @param root
*/
void Solution::ShuangXiangBFS(MoreTreeNode* begin, MoreTreeNode* target) {
// 假设是图
std::queue<MoreTreeNode*> min, max;
min.push(begin);
max.push(target);
bool found = false;
std::unordered_map<MoreTreeNode*, int> visited;
visited[begin] = 1, visited[target] = 2; //初始状态下默认设置成1（正向）和2（反向）
// flag作为区分两个队列的标志
auto extend_node = [&](std::queue<MoreTreeNode*> queues, bool flag) {
MoreTreeNode* node = queues.front();
queues.pop();
// 访问所有子结点
for (int i = 0; i < node->nexts.size(); i++) {
MoreTreeNode* next = node->nexts[i];
if (flag) {
if (visited[next] != 1) { // 没在正向队列中出现
if (visited[next] == 2) { // 在反向队列中出现过，说明已经找到了
found = true;
return;
}
visited[next] = 1; //做标记
queues.push(next);
}
}
else {
if (visited[next] != 2) { // 同上
if (visited[next] == 1) {
found = true;
return;
}
visited[next] = 2;
queues.push(next);
}
}
}
};
while (!min.empty() || !max.empty()) {
if (!min.empty()) {
extend_node(min, true);
}
if (found) {
return ;
}
if (!max.empty()) {
extend_node(max, false);
}
if (found) {
return ;
}
}
}
其实上面的代码并不完全正确，仍然需要进行优化，比如说会遇到这样的情况
求S-T的最短路，交替节点搜索（一次正向节点，一次反向节点）时
while(1):
S –> 1
T –> 3
while(2):
S -> 5
T -> 4
while(3):
1 -> 5
3 -> 5 返回最短路为4，错误的，事实是3，S-2-4-T
正确做法的是交替逐层搜索，保证了不会先遇到非最优解就跳出，而是检查完该层所有节点，得到最优值。也即如果该层搜索遇到了对方已经访问过的，那么已经搜索过的层数就是答案了，可以跳出了，以后不会更优的了。
下面的代码进行优化：优先去访问结点少的层。
#include <stdio.h>
#include <stdlib.h>
#include <queue>
#include <iostream>
using namespace std;
int l; //4<=l<=300
int sx,sy,tx,ty;
int a[305][305]; //正向搜索层次
int b[305][305]; //反向搜索层次
struct point{
int x,y;
};
struct point dir[]=
{
{1,2},{1,-2},{-1,2},{-1,-2},
{2,1},{2,-1},{-2,1},{-2,-1}
};
bool check(int x,int y){
if(x>=0 && x<l && y>=0 && y<l)
return true;
else
return false;
}
void dbfs(){
memset(a,-1,sizeof(a));
memset(b,-1,sizeof(b));
a[sx][sy]=0;
b[tx][ty]=0;
queue<point> forQ,backQ;
point p1,p2;
p1.x=sx;
p1.y=sy;
p2.x=tx;
p2.y=ty;
forQ.push(p1);
backQ.push(p2);
//正反向队列至少还有一个可以扩展
while(forQ.empty()==false || backQ.empty()==false){
//优化：优先扩展元素少的队列（如果只有一个队列非空，则扩展非空队列）
int forSize=forQ.size();
int backSize=backQ.size();
if(backSize==0 || forSize<backSize){
//扩展正向队列一层
int i;
for(i=0;i<forSize;i++){
point cur=forQ.front();
forQ.pop();
if(b[cur.x][cur.y]!=-1){
printf("%d\n",a[cur.x][cur.y]+b[cur.x][cur.y]);
return;
}
int j;
for(j=0;j<8;j++){
if(check(cur.x+dir[j].x, cur.y+dir[j].y)){
point next={cur.x+dir[j].x, cur.y+dir[j].y}; //!注意struct的创建方式
if(a[next.x][next.y]!=-1)//以前已经正向扩展过
continue;
a[next.x][next.y]=a[cur.x][cur.y]+1;
forQ.push(next);
}
}
}
}else{
//扩展反向队列一层
int i;
for(i=0;i<backSize;i++){
point cur=backQ.front();
backQ.pop();
if(a[cur.x][cur.y]!=-1){
printf("%d\n",a[cur.x][cur.y]+b[cur.x][cur.y]);
return;
}
int j;
for(j=0;j<8;j++){
if(check(cur.x+dir[j].x, cur.y+dir[j].y)){
point next={cur.x+dir[j].x, cur.y+dir[j].y};
if(b[next.x][next.y]!=-1)
continue;
b[next.x][next.y]=b[cur.x][cur.y]+1;
backQ.push(next);
}
}
}
}
}//end while
printf("0");
}
int main(void){
int time;
scanf("%d",&time);
while(time-->0){
scanf("%d%d%d%d%d\n",&l,&sx,&sy,&tx,&ty);
dbfs();
}
return 0;
}
练习
网络上有这么一道题，骑士移动
这道题就可以用到BFS，双向BFS，A*(有目的的BFS)来解决
BFS
/**
* 骑士题目
* 给定起点和终点，按照骑士的走法，求解最短路数
*/
// 使用bfs实现（核心代码）
void qishi_bfs() {
typedef struct Node {
int x, y;
int step;
};
int dis[8][2]={{-2,1},{-2,-1},{-1,-2},{-1,2},{2,-1},{2,1},{1,-2},{1,2}};
std::vector< std::vector<int>> visited(8, std::vector<int>(8, 0)); // 8*8
Node start, end;
// 边界判断
auto isValid = [&](Node node) {
if (node.x < 0 || node.y < 0 || node.x > 7 || node.y > 7) {
return false;
}
return true;
};
// 是否为结果
auto isTarget = [&](Node node1, Node node2) {
if (node1.x == node2.x && node1.y == node2.y) {
return true;
}
return false;
};
std::queue<Node> queue;
queue.push(start);
visited[start.x][start.y] = 1;
auto state_bfs = [&]() {
while(!queue.empty()) {
Node next = queue.front();
queue.pop();
if (isTarget(start, next)) {
std::cout << next.step << std::endl;
break;
}
// 方可可以到达的哈什湖上
for (int i = 0; i < 8; ++i) {
Node t;
t.x = next.x + dis[i][0];
t.y = next.y + dis[i][1];
if (isValid(t) && visited[t.x][t.y] == 0) {
visited[t.x][t.y] = 1;
t.step = next.step + 1;
queue.push(t);
}
}
}
};
state_bfs();
}
双向BFS
// 使用双队列的bfs实现（核心代码）
void qishi_double_bfs() {
typedef struct Node {
int x, y;
int step;
};
int dis[8][2]={{-2,1},{-2,-1},{-1,-2},{-1,2},{2,-1},{2,1},{1,-2},{1,2}};
std::vector< std::vector<int>> level(8, std::vector<int>(8, 0)); // 8*8
std::vector< std::vector<int>> color(8, std::vector<int>(8, 0)); // 区分队列
Node start, end;
std::queue<Node> queue_start;
queue_start.push(start);
level[start.x][start.y] = 0;
color[start.x][start.y] = 1;
std::queue<Node> queue_end;
queue_start.push(end);
level[end.x][end.y] = 1; //因为起点和终点必然不是重合的，它们之间至少存在1的距离
color[start.x][start.y] = 2;
// 边界判断
auto isValid = [&](Node node) {
if (node.x < 0 || node.y < 0 || node.x > 7 || node.y > 7) {
return false;
}
return true;
};
auto state_bfs = [&](std::queue<Node> queue, bool flag) {
while(!queue.empty()) {
Node next = queue.front();
queue.pop();
// 方可可以到达的哈什湖上
for (int i = 0; i < 8; ++i) {
Node t;
t.x = next.x + dis[i][0];
t.y = next.y + dis[i][1];
if (isValid(t)) {
continue;
}
if (flag) {
if (color[t.x][t.y] == 0) {
color[t.x][t.y] = 1;
level[t.x][t.y] = level[next.x][next.y] + 1;
queue.push(t);
}
else if (color[t.x][t.y] == 2) {
return level[t.x][t.y] + level[next.x][next.y];
}
}
else {
if (color[t.x][t.y] == 0) {
color[t.x][t.y] = 2;
level[t.x][t.y] = level[next.x][next.y] + 1;
queue.push(t);
}
else if (color[t.x][t.y] == 1) {
return level[t.x][t.y] + level[next.x][next.y];
}
}
}
}
};
// 避免出现起始或者结束中没有下一步的结点，也就是可能中间断掉了
while (!queue_start.empty() || !queue_end.empty()) {
if (!queue_start.empty()) {
state_bfs(queue_start, true);
}
if (!queue_end.empty()) {
state_bfs(queue_end, true);
}
}
}
A*
因为这个稍微有些复杂，所以会单独写一篇文章来描述。
其他
当我们已经获取到了图的邻接表的时候，要求从起始结点到目标结点的路径，应该怎么求呢？
/**
* 反向生成路径，但是需要注意的地方在于，其只能生成一条路径
* 要么你每次在主程序中得到目标结点后，就收敛然后使用这个函数
* @tparam state_t
* @param father
* @param target
* @return
*/
template <typename state_t>
std::vector<state_t> gen_path(const std::unordered_map<state_t, state_t> father, const state_t& target) {
std::vector<state_t> path;
path.push_back(target);
// 从叶结点一直到访问到根结点（不再存在父结点）
for (state_t cur = target; father.find(cur) != father.end(); cur = father.at(cur)) {
path.push_back(cur);
}
std::reverse(path.begin(), path.end());
return path;
}
/**
* 很显然，对于多条路径的计算方法，DFS再合适不过了，
* 此时nexts为邻接表，纪录每个结点的相关的状态数组
* @tparam state_t
*/
template <typename state_t>
std::vector<std::vector<state_t>> results;
template <typename state_t>
void get_more_path(const std::unordered_map<state_t, std::vector<state_t>> nexts, std::vector<state_t> path, state_t cur, state_t target) {
// 达到目标后收敛
if (cur == target) {
results.push_back(path);
return ;
}
else {
std::vector<state_t> next = nexts[cur];
for (int i = 0; i < next.size(); i++) {
state_t now = next[i];
path.push_back(now);
get_more_path(nexts, path, now, target);
path.pop_back();
}
}
}
关注公众号：数据结构与算法那些事儿，每天一篇数据结构与算法
