双向广度优先搜索的三种实现方式

📌 单队列交替扩展法

这是最早期的极简实现，将起点和终点同时放入同一个队列，正向和逆向搜索交替从队列头部取节点扩展，直到出现重复节点即终止。

✅ ‌优点‌

代码实现极其简洁，仅需维护1个队列和1个全局访问标记数组，上手门槛极低，内存占用最小，不需要额外开辟第二份队列空间；

❌ ‌缺点‌

两个方向的扩展顺序完全随机，极易出现单侧搜索树快速膨胀的情况，效率不稳定，无法精准记录两个方向各自的搜索步数，路径重建逻辑非常容易出错；

⭐ 推荐星级：⭐⭐
🔍 适用场景：仅适合状态空间极小、分支因子极低的入门级练习题。

📋 例题：P1032 [NOIP 2002 提高组] 字串变换

 

#include<bits/stdc++.h>
#include<iostream>
using namespace std;
string A,B;

int n=0;
string a[10],b[10];
unordered_map< string,pair<int,int> > mp; // < 字符串, <最小步数, 方向> > 

void bfs(){
    queue<string> q;
    q.push(A);
    q.push(B);
    mp[A] = make_pair(0,1);
    mp[B] = make_pair(0,2);
    while( q.size() ){
        string f = q.front(); q.pop();
        for( int i=0;i<n;i++ ){
            size_t index =  0 ;
            while(true ) {
                string ts = f;
                if( mp[ts].first >= 10 ) continue; 
                index =  f.find( a[i] , index ); 
                if( index == string::npos ) break;                
                ts.replace( index , a[i].length() , b[i] );
                if( mp.count(ts)==0 ){
                    q.push( ts );
                    mp[ts].first = mp[f].first + 1;
                    mp[ts].second = mp[f].second ;
                } 
                else if( mp[ts].second != mp[f].second ){
                    cout << mp[ts].first + mp[f].first + 1;
                    return ;
                }        
                index += a[i].length();
                if( index + a[i].length() > f.length() ) break;        
            }
        }
    }
    cout << "NO ANSWER!";
} 

int main(){
    cin>>A>>B;
    while( cin>>a[n] ){
        cin>>b[n++]; 
    }
    bfs(); 
    return 0;
}

 

 

 

---

 

📌 双队列等层交替扩展法

这是最经典的常规实现，分别维护正向、逆向两个独立队列，每次完整扩展完正向的一整层节点，再切换到逆向扩展一整层，交替循环直到相遇。

✅ ‌优点‌
逻辑清晰直观，两个方向的步数独立维护，相遇时能直接通过步数相加得到最短路径长度，完全保留BFS的层序特性，天然保证最短路径的最优性，路径重建难度低；
❌ ‌缺点‌
没有考虑两个方向的节点生成速度差异，若其中一侧分支因子远大于另一侧，会出现单侧队列爆炸，性能退化为接近单向BFS，固定交替的策略无法适配非完全树的场景，容易做大量无效扩展；
⭐ 推荐星级：⭐⭐⭐⭐

🔍 适用场景：图结构对称、两个方向分支因子相近的场景，比如标准迷宫寻路、规则对称的拼图游戏。

📋 例题：P1746 离开中山路

#include<iostream>
#include<queue>
using namespace std;
int dx[]{1,-1,0,0} , dy[]{0,0,1,-1};
char maze[1005][1005];
bool vis1[1005][1005],vis2[1005][1005];
int n,x1,y1,x2,y2;
struct node{
    int x,y;
};

int bfs(){
    if( x1==x2 && y1==y2 ) return 0;
    queue< node > q1 , q2 ;    
    q1.push( {x1,y1} ); vis1[x1][y1] = 1;
    q2.push( {x2,y2} ); vis2[x2][y2] = 1;    
    int step = 0;
    while( q1.size() && q2.size() ){
        step++;
        int size1 = q1.size() ;
        while( size1-- ){
            int x = q1.front().x , 
                y = q1.front().y ;
            q1.pop();
            for( int i=0;i<4;i++ ){
                int tx = x + dx[i],
                    ty = y + dy[i];
                if( tx<1 || tx>n || ty<1 || ty> n) continue;
                if( maze[tx][ty]=='1' ) continue;
                if( vis2[tx][ty] ) return step;
                if( vis1[tx][ty] ) continue;
                q1.push( {tx,ty} );
                vis1[tx][ty] = 1;
            }
        }
        step++;
        int size2 = q2.size() ;
        while( size2-- ){
            int x = q2.front().x , 
                y = q2.front().y ;
            q2.pop();
            for( int i=0;i<4;i++ ){
                int tx = x + dx[i],
                    ty = y + dy[i];
                if( tx<1 || tx>n || ty<1 || ty> n) continue;
                if( maze[tx][ty]=='1' ) continue;
                if( vis1[tx][ty] ) return step;
                if( vis2[tx][ty] ) continue;
                q2.push( {tx,ty} );
                vis2[tx][ty] = 1;
            }
        }
    }
    return -1;
}


int main(){
    ios::sync_with_stdio(false);cin.tie(0);
    cin>>n;
    for(int i=1;i<=n;i++){
        for(int j=1;j<=n;j++){
            cin>>maze[i][j];
        }
    }
    cin>>x1>>y1>>x2>>y2;
    cout << bfs();
    return 0;
}

---

 

📌 优先扩展小队列动态平衡法

这是目前工业界和信奥竞赛中最常用的优化实现，每次动态比较两个队列的当前节点数，优先选择规模更小的一侧进行扩展，始终保持两个方向的搜索树规模接近。

✅ ‌优点‌
从根本上解决了两个方向扩展速度不平衡的问题，能最大化发挥双向BFS的指数级效率优势，节点扩展量通常比前两种方式少30%以上；

性能表现稳定，即使在非完全树、分支因子不对称的场景下，也能避免单侧队列膨胀
❌ ‌缺点‌
实现复杂度最高，需要额外增加队列大小判断逻辑，调试时需要同时跟踪两个方向的扩展状态；
极端场景下（比如其中一个方向完全没有分支），动态切换的额外判断开销会小幅抵消性能收益；
⭐ 推荐星级：⭐⭐⭐⭐⭐
🔍 适用场景：几乎所有双向BFS的生产级场景，比如单词接龙、八数码问题、社交网络最短路径查询等状态空间较大的任务。

📋 例题：P1379 八数码难题

#include<bits/stdc++.h>
using namespace std;
string s, t = "123804765";
int d[4] = {1, -1, 3, -3};
unordered_set<string> vis1,vis2;
int bfs(){
    if( s==t ) return 0;
    queue<string> q1,q2;
    q1.push(s); 
    q2.push(t);
    vis1.insert(s); 
    vis2.insert(t);
    int step = 0;
    while( q1.size()&&q2.size() ){
        if( q1.size() > q2.size() ){
            swap(q1,q2);
            swap(vis1,vis2);
        }
        step++;
        int sz = q1.size();
        while(sz--){
            string f = q1.front(); q1.pop();
            int c = f.find('0');
            for(int i = 0; i < 4; i++){
                int t = d[i] + c;
                string fs = f;
                if(t < 0 or t > 8) continue;
                else if( i==0 && c%3==2  ) continue; 
                else if( i==1 && c%3==0  ) continue;
                swap(fs[t], fs[c]);
                if( vis2.count(fs) ) return step;
                if( vis1.count(fs) ) continue;
                q1.push(fs);
                vis1.insert(fs);
            }            
        }
    } 
    return -1;
}
int main(){
    cin >> s;
    cout << bfs() << endl;
    return 0;
} 

---

 

⚖️bfs不同实现方式的时间对比

例题：P1032 [NOIP 2002 提高组] 字串变换

#include<bits/stdc++.h>
#include<iostream>
using namespace std;
string A,B;

int n=0;
string a[10],b[10];
map<string,int> step; //step:记录s的步数

void bfs(){
    queue<string> q;
    q.push(A);
    step[A] = 0;
    while( q.size() ){
        string f = q.front();q.pop();
        if( f==B ) {
            cout << step[B] ;
            return ; 
        }
        for( int i=0;i<n;i++ ){
            size_t index =  0 ;
            while(true ) {
                string ts = f;
                index =  f.find(a[i],index ); 
                if( index==string::npos ) break;                
                ts.replace( index,a[i].length(),b[i] );
                if( step.count(ts)==0 ){
                    q.push( ts );
                    step[ts] = step[f]+1;
                }     
                index += a[i].length();
                if( index >= f.length()) break;        
            }
        }
    }
    cout << "NO ANSWER!";
} 

int main(){
    cin>>A>>B;
    while( cin>>a[n] ){
        cin>>b[n++]; 
    }
    bfs(); 
    return 0;
}

#include<bits/stdc++.h>
#include<iostream>
using namespace std;
string A,B;

int n=0;
string a[10],b[10];
unordered_map< string,pair<int,int> > mp; // < 字符串, <最小步数, 方向> > 

void bfs(){
    queue<string> q;
    q.push(A);
    q.push(B);
    mp[A] = make_pair(0,1);
    mp[B] = make_pair(0,2);
    while( q.size() ){
        string f = q.front(); q.pop();
        for( int i=0;i<n;i++ ){
            size_t index =  0 ;
            while(true ) {
                string ts = f;
                if( mp[ts].first >= 10 ) continue; 
                index =  f.find( a[i] , index ); 
                if( index == string::npos ) break;                
                ts.replace( index , a[i].length() , b[i] );
                if( mp.count(ts)==0 ){
                    q.push( ts );
                    mp[ts].first = mp[f].first + 1;
                    mp[ts].second = mp[f].second ;
                } 
                else if( mp[ts].second != mp[f].second ){
                    cout << mp[ts].first + mp[f].first + 1;
                    return ;
                }        
                index += a[i].length();
                if( index + a[i].length() > f.length() ) break;        
            }
        }
    }
    cout << "NO ANSWER!";
} 

int main(){
    cin>>A>>B;
    while( cin>>a[n] ){
        cin>>b[n++]; 
    }
    bfs(); 
    return 0;
}

#include<bits/stdc++.h>
using namespace std;
string s, t = "123804765";
int d[4] = {1, -1, 3, -3};
unordered_set<string> vis1,vis2;
int bfs(){
    if( s==t ) return 0;
    queue<string> q1,q2;
    q1.push(s);
    q2.push(t);
    vis1.insert(s);
    vis2.insert(t);
    int step = 0;
    while( q1.size()&&q2.size() ){
        if( q1.size() > q2.size() ){
            swap(q1,q2);
            swap(vis1,vis2);
        }
        step++;
        int sz = q1.size();
        while(sz--){
            string f = q1.front(); q1.pop();
            int c = f.find('0');
            for(int i = 0; i < 4; i++){
                int t = d[i] + c;
                string fs = f;
                if(t < 0 or t > 8) continue;
                else if( i==0 && c%3==2  ) continue;
                else if( i==1 && c%3==0  ) continue;
                swap(fs[t], fs[c]);
                if( vis2.count(fs) ) return step;
                if( vis1.count(fs) ) continue;
                q1.push(fs);
                vis1.insert(fs);
            }
        }
    }
    return -1;
}
int main(){
    cin >> s;
    cout << bfs() << endl;
    return 0;
}

 

例题：P1379 八数码难题

#include<bits/stdc++.h>
using namespace std;
string s, t = "123804765";
int d[4] = {1, -1, 3, -3};
struct node{string s; int step;};
unordered_set<string> vis;
int bfs(){
    queue<node> q;
    q.push((node){s,0});
    vis.insert(s);
    while( q.size() ){
        node f = q.front(); q.pop();
        if(f.s == t) return f.step;
        int c = f.s.find('0');
        for(int i = 0; i < 4; i++){
            int t = d[i] + c;
            string fs = f.s;
            if(t < 0 or t > 8) continue;
            else if( i==0 && c%3==2  ) continue; 
            else if( i==1 && c%3==0  ) continue;
            swap(fs[t], fs[c]);
            if( vis.count(fs) ) continue;
            q.push((node){fs, f.step + 1});
            vis.insert(fs);
        }
    } 
    return -1;
}
int main(){
    cin >> s;
    cout << bfs() << endl;
    return 0;
} 

#include<bits/stdc++.h>
using namespace std;
string s, t = "123804765";
int d[4] = {1, -1, 3, -3};
unordered_set<string> vis1,vis2;
int bfs(){
    if( s==t ) return 0;
    queue<string> q1,q2;
    q1.push(s); 
    q2.push(t);
    vis1.insert(s); 
    vis2.insert(t);
    int step = 0;
    while( q1.size()&&q2.size() ){
        if( q1.size() > q2.size() ){
            swap(q1,q2);
            swap(vis1,vis2);
        }
        step++;
        int sz = q1.size();
        while(sz--){
            string f = q1.front(); q1.pop();
            int c = f.find('0');
            for(int i = 0; i < 4; i++){
                int t = d[i] + c;
                string fs = f;
                if(t < 0 or t > 8) continue;
                else if( i==0 && c%3==2  ) continue; 
                else if( i==1 && c%3==0  ) continue;
                swap(fs[t], fs[c]);
                if( vis2.count(fs) ) return step;
                if( vis1.count(fs) ) continue;
                q1.push(fs);
                vis1.insert(fs);
            }            
        }
        step++;
        sz = q2.size();
        while(sz--){
            string f = q2.front(); q2.pop();
            int c = f.find('0');
            for(int i = 0; i < 4; i++){
                int t = d[i] + c;
                string fs = f;
                if(t < 0 or t > 8) continue;
                else if( i==0 && c%3==2  ) continue; 
                else if( i==1 && c%3==0  ) continue;
                swap(fs[t], fs[c]);
                if( vis1.count(fs) ) return step;
                if( vis2.count(fs) ) continue;
                q2.push(fs);
                vis2.insert(fs);
            }            
        }
    } 
    return -1;
}
int main(){
    cin >> s;
    cout << bfs() << endl;
    return 0;
} 

#include<bits/stdc++.h>
using namespace std;
string s, t = "123804765";
int d[4] = {1, -1, 3, -3};
unordered_set<string> vis1,vis2;
int bfs(){
    if( s==t ) return 0;
    queue<string> q1,q2;
    q1.push(s); 
    q2.push(t);
    vis1.insert(s); 
    vis2.insert(t);
    int step = 0;
    while( q1.size()&&q2.size() ){
        if( q1.size() > q2.size() ){
            swap(q1,q2);
            swap(vis1,vis2);
        }
        step++;
        int sz = q1.size();
        while(sz--){
            string f = q1.front(); q1.pop();
            int c = f.find('0');
            for(int i = 0; i < 4; i++){
                int t = d[i] + c;
                string fs = f;
                if(t < 0 or t > 8) continue;
                else if( i==0 && c%3==2  ) continue; 
                else if( i==1 && c%3==0  ) continue;
                swap(fs[t], fs[c]);
                if( vis2.count(fs) ) return step;
                if( vis1.count(fs) ) continue;
                q1.push(fs);
                vis1.insert(fs);
            }            
        }
    } 
    return -1;
}
int main(){
    cin >> s;
    cout << bfs() << endl;
    return 0;
}