BFS算法框架

BFS算法框架

  BFS的核心思想，就是把一些问题抽象成图，从一个节点开始，向四周扩散。一般来说，写BFS都是用[队列]这个数据结构，每次将一个节点周围的节点加入到队尾。

  BFS相对于DFS的最主要区别是：BFS找到的路径一定是最短的，但代价就是空间复杂度比DFS大很多。本文从两道经典的BFS题目来讲解。

先举例⼀下 BFS 出现的常⻅场景好吧， 问题的本质就是让你在⼀幅「图」 中找到从起点 start 到终点 target 的最近距离， 这个例⼦听起来很枯燥， 但是 BFS 算法问题其实都是在⼲这个事⼉， 把枯燥的本质搞清楚了， 再去欣赏各种问题的包装才能胸有成竹嘛。

• ⽐如⾛迷宫， 有的格⼦是围墙不能⾛， 从起点到终点的最短距离是多少？如果这个迷宫带「传送门」 可以瞬间传送呢？

• ⽐如说两个单词， 要求你通过某些替换， 把其中⼀个变成另⼀个， 每次只能替换⼀个字符， 最少要替换⼏次？

• ⽐如说连连看游戏， 两个⽅块消除的条件不仅仅是图案相同， 还得保证两个⽅块之间的最短连线不能多于两个拐点。 你玩连连看， 点击两个坐标， 游戏是如何判断它俩的最短连线有⼏个拐点的？

  这些问题都没啥奇技淫巧， 本质上就是⼀幅「图」 ， 让你从⼀个起点， ⾛到终点， 问最短路径。 这就是 BFS 的本质， 框架搞清楚了直接默写就好。

BFS框架：

int BFS(Node start, Node target){
    // 核心数据结果：队列
    queue<Node> q;
    // 标记集合，避免走回头路
    set<Node> visited;
    // 首先将起点加入队尾
    q.push(start);
    // 记录扩散的次数（其实就是要求的路径长度）
    int step = 0;
    while(!q.empty()){
        int sz = q.size();
        // 将当前队列中的所有节点向其”周围（图就是邻接点，二叉树就是子节点）“扩散
        for(int i = 0; i < sz; i++){
            // 获取队首元素并将其出列
            Node cur = q.front();
            q.pop();
            // 划重点，这里判断是否到达终点
            if(cur is target)
                return step;
            
            // 将当前节点cur的所有相邻节点加入队尾
            for(Node p : cur.adj()){
                if(p not in visited){
                    // 加入队尾
                    q.push(p);
                    // 标记
                    visited.add(p);
                }
            }
        }
        // 划重点，更新步数在这里
        step++;
    }
}

其中，cur.adj()表示节点cur的相邻节点（图即邻接点，树即子节点）。

经典例题一：二叉树的最小高度（leetcode.111）

  怎么套到 BFS 的框架⾥呢？⾸先明确⼀下起点 start 和终点 target 是什么，怎么判断到达了终点？显然起点就是 root 根节点， 终点就是最靠近根节点的那个「叶⼦节点」嘛， 叶⼦节点就是两个⼦节点都是 null 的节点：

if(cur->left == nullprt && cur->right == nullptr)
	//到达叶子结点，返回

  那么，按照BFS框架稍加改造：

#include <queue>

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    int minDepth(TreeNode* root) {
        if(root == nullptr)
            return 0;
        queue<TreeNode*> q;
        // 将起点加入到队尾
        q.push(root);
        int depth = 1;
        while(!q.empty()){
            int sz = q.size();
            // 将当前队列中的所有节点向四周扩散
            for(int i = 0; i < sz; i++){
                // 每次取出队首节点
                TreeNode* cur = q.front();
                q.pop();
                // 这里判断是否到达终点
                if(cur->left == nullptr && cur->right == nullptr)
                    return depth;
                // 将cur的相邻节点加入队尾
                if(cur->left != nullptr)
                    q.push(cur->left);
                if(cur->right != nullptr)
                    q.push(cur->right);
            }
            // 划重点，更新步数在这里
            depth++;
        }
        return depth;
    }
};

经典例题二：打开转盘锁（leetcode.752）

直接上代码：

#include <string>
#include <queue>

class Solution {
public:
    // 将s[i]向上拨
    string plusOne(string s, int i){
        if(s[i] =='9')
            s[i] = '0';
        else 
            s[i] = s[i] + 1;
        return s;
    }

    // 将s[i]向下拨
    string minusOne(string s, int i){
        if(s[i] == '0')
            s[i] = '9';
        else
            s[i] = s[i] - 1;
        return s;
    }  

    int BFS(vector<string> &deadends, string target){
        queue<string> q;
        set<string> visited;
        set<string> deads;
        for(int i = 0; i < deadends.size(); i++)
            deads.insert(deadends[i]);
        int step = 0;
        q.push("0000");
        visited.insert("0000");
        while(!q.empty()){
            int sz = q.size();
            for(int i = 0; i < sz; i++){
                string cur = q.front();
                q.pop();
                // 跳过死锁
                if(deads.find(cur) != deads.end())
                    continue;
                if(cur == target){
                    printf("%d
", step);
                    return step;
                }
                // 将该结点的所有子节点加入队尾
                for(int i = 0; i < 4; i++){
                    string adjPlus = plusOne(cur, i);
                    string adjMinus = minusOne(cur, i);
                    if(visited.find(adjPlus) == visited.end()){
                        q.push(adjPlus);
                        visited.insert(adjPlus);
                    }
                    if(visited.find(adjMinus) == visited.end()){
                        q.push(adjMinus);
                        visited.insert(adjMinus);
                    }
                }
            }
            step++;
        }
        return -1;
    }

    int openLock(vector<string>& deadends, string target) {
        return BFS(deadends, target);
    }
};