9.4双向BFS

一、双向BFS核心思想

双向广度优先搜索（Bidirectional BFS）是一种优化策略，通过从起点和终点同时进行BFS，在中间相遇时终止搜索。适用于：

• 明确起点和终点的场景
• 搜索空间较大的最短路径问题
• 分支因子（Branching Factor）较大的图结构

二、算法优势分析

（b为分支因子，d为起点到终点的深度）

三、算法执行流程

1. 初始化双队列

   • 起点队列q_start：从起点开始
   • 终点队列q_end：从终点开始
   • 两个访问记录visited_start、visited_end

2. 交替层扩展

   • 每次选择较小的队列进行扩展（平衡搜索速度）
   • 优先扩展层级较低的队列

3. 相遇检测

   • 当前节点在对方访问记录中存在时触发
   • 合并路径得到完整路径

四、代码实现框架

#include <iostream>
#include <queue>
#include <vector>
#include <unordered_map>
using namespace std;

int bidirectionalBFS(int start, int target, vector<vector<int>>& graph) {
    if (start == target) return 0;

    queue<int> q_start, q_end;
    unordered_map<int, int> visited_start, visited_end;

    // 初始化双队列
    q_start.push(start);
    visited_start[start] = 0;
    q_end.push(target);
    visited_end[target] = 0;

    while (!q_start.empty() && !q_end.empty()) {
        // 选择较小的队列先扩展
        int res = -1;
        if (q_start.size() <= q_end.size()) {
            res = expand(q_start, visited_start, visited_end, graph);
        } else {
            res = expand(q_end, visited_end, visited_start, graph);
        }
      
        if (res != -1) return res;
    }
    return -1;  // 无通路
}

int expand(queue<int>& q, 
          unordered_map<int, int>& curr_vis,
          unordered_map<int, int>& other_vis,
          vector<vector<int>>& graph) {
    int size = q.size();
    while (size--) {
        int curr = q.front();
        q.pop();
      
        for (int neighbor : graph[curr]) {
            if (curr_vis.count(neighbor)) continue;
          
            // 相遇检测
            if (other_vis.count(neighbor)) {
                return curr_vis[curr] + 1 + other_vis[neighbor];
            }
          
            curr_vis[neighbor] = curr_vis[curr] + 1;
            q.push(neighbor);
        }
    }
    return -1;
}

五、关键实现细节

1. 队列选择策略

// 优先扩展较小队列（平衡搜索速度）
if (q_start.size() <= q_end.size()) {
    // 扩展起点队列
} else {
    // 扩展终点队列
}

2. 层级记录方式

// 使用unordered_map记录节点及其层级
unordered_map<int, int> visited_start;  // <节点, 层级>
visited_start[start] = 0;

3. 相遇条件判断

// 当发现当前节点在对方已访问时
if (other_vis.count(neighbor)) {
    return curr_level + 1 + other_vis[neighbor];
}

六、实战案例：单词接龙

问题描述

给定起始单词（如"hit"）和结束单词（如"cog"），以及字典列表，每次只能改变一个字母，求最短转换序列长度。

双向BFS优化实现

int ladderLength(string beginWord, string endWord, vector<string>& wordList) {
    unordered_set<string> dict(wordList.begin(), wordList.end());
    if (!dict.count(endWord)) return 0;

    unordered_set<string> q_start{beginWord};
    unordered_set<string> q_end{endWord};
    unordered_map<string, int> visited_start{{beginWord, 1}};
    unordered_map<string, int> visited_end{{endWord, 1}};

    while (!q_start.empty() && !q_end.empty()) {
        // 选择较小的集合进行扩展
        if (q_start.size() > q_end.size()) {
            swap(q_start, q_end);
            swap(visited_start, visited_end);
        }

        unordered_set<string> temp;
        for (const string& word : q_start) {
            int curr_len = visited_start[word];
            for (int i = 0; i < word.size(); ++i) {
                string new_word = word;
                for (char c = 'a'; c <= 'z'; ++c) {
                    new_word[i] = c;
                    if (!dict.count(new_word)) continue;

                    if (visited_end.count(new_word)) {
                        return curr_len + visited_end[new_word];
                    }

                    if (!visited_start.count(new_word)) {
                        visited_start[new_word] = curr_len + 1;
                        temp.insert(new_word);
                    }
                }
            }
        }
        q_start = temp;
    }
    return 0;
}

优化点解析

1. 使用unordered_set代替队列：方便快速查找
2. 交换队列策略：保持始终扩展较小的集合
3. 提前终止检测：发现共同节点立即返回

七、性能对比测试

以8x8网格最短路径为例：

八、适用场景判断

适合使用双向BFS的情况：

1. 明确的起点和终点
2. 图结构对称性较好
3. 分支因子较大的图（b > 2）
4. 需要快速找到最短路径

不适合的情况：

1. 终点不明确（迷宫出口未知）
2. 动态变化的图结构
3. 需要记录所有路径而不仅是长度

九、常见问题调试

1. 队列不同步：

   • 现象：相遇检测失效
   • 解决：确保双方使用相同的节点标识方式

2. 层级计算错误：

   // 错误示例：忘记+1层级
   visited[neighbor] = visited[curr];  // 错误！
   visited[neighbor] = visited[curr] + 1; // 正确
   

3. 字典冲突处理：

   // 需要先确认新单词在字典中
   if (!dict.count(new_word)) continue;
   

如果需要特定领域的具体实现（如社交网络好友推荐、交通路径规划），可以告诉我具体需求，我可以提供更针对性的实现方案和优化建议。