双向广搜——AcWing 190. 字串变换

双向广搜

定义

双向广搜是图搜索算法的一种变体，与传统的单向广搜不同，它同时从起点和终点（或目标状态）开始进行搜索，直到两个搜索的前沿相遇为止。这种方法可以在某些情况下显著减少搜索空间，尤其是在寻找两点间的最短路径时特别有效，因为搜索不是从一端到另一端，而是从两端向中间靠拢。

运用情况

1. 最短路径问题：特别是在图较大或目标距离较远时，双向BFS可以显著减少搜索时间。
2. 游戏AI：在某些游戏中，为了快速找到从角色当前位置到目标位置的最短路径，可以使用双向BFS。
3. 网络路由：在复杂的网络环境中寻找两个节点间的最短通信路径。
4. 拼写检查：在字典中快速查找两个单词的最短变换序列（如通过编辑距离）。

注意事项

1. 相遇条件：需要设计一个机制来检测或标记已经探索过的节点，以避免重复探索，并能在两个搜索的前沿相遇时停止搜索。
2. 空间复杂度：虽然双向BFS通常比单向BFS更快找到解，但它可能需要更多的内存来存储两个队列的数据。
3. 平衡问题：为了优化效率，需要确保两个方向的搜索速度尽量均衡，避免一边搜索过快导致另一边的搜索变得冗余。
4. 起点和终点的可达性：在开始搜索之前，应确认起点和终点都在同一个连通分量内，否则没有路径可寻。

解题思路

1. 初始化：设置两个队列，一个用于从起点开始搜索，另一个从终点开始搜索。同时，创建两个集合或数据结构来记录各自已探索的节点。
2. 执行广搜：在每一步中，从两个队列中各取出一层节点进行扩展。对于从起点出发的队列，向目标方向扩展；对于从终点出发的队列，则向起点方向扩展。在扩展时，检查新节点是否已经在对方的已探索集合中出现，这表明两个搜索前沿相遇，此时可以停止搜索。
3. 相遇检测：设计一种机制来标记或检查节点是否属于对方的搜索空间。这可以通过共享一个全局已探索节点集合，或在每次扩展时检查新节点是否在对方的队列中来实现。
4. 路径合并：一旦两个前沿相遇，可以通过追踪相遇节点的父节点，反向构造从起点到终点的完整路径。
5. 优化：为了平衡两边的搜索速度，可以根据图的性质动态调整，比如根据每一轮扩展的节点数量调整，或者优先扩展节点数较少的一边。

AcWing 190. 字串变换

题目描述

AcWing 190. 字串变换 - AcWing

运行代码

#include <iostream>
#include <cstring>
#include <algorithm>
#include <queue>
#include <unordered_map>

using namespace std;

const int N = 6;

int n;
string A, B;
string a[N], b[N];

int extend(queue<string>& q, unordered_map<string, int>&da, unordered_map<string, int>& db, 
    string a[N], string b[N])
{
    int d = da[q.front()];
    while (q.size() && da[q.front()] == d)
    {
        auto t = q.front();
        q.pop();

        for (int i = 0; i < n; i ++ )
            for (int j = 0; j < t.size(); j ++ )
                if (t.substr(j, a[i].size()) == a[i])
                {
                    string r = t.substr(0, j) + b[i] + t.substr(j + a[i].size());
                    if (db.count(r)) return da[t] + db[r] + 1;
                    if (da.count(r)) continue;
                    da[r] = da[t] + 1;
                    q.push(r);
                }
    }

    return 11;
}

int bfs()
{
    if (A == B) return 0;
    queue<string> qa, qb;
    unordered_map<string, int> da, db;

    qa.push(A), qb.push(B);
    da[A] = db[B] = 0;

    int step = 0;
    while (qa.size() && qb.size())
    {
        int t;
        if (qa.size() < qb.size()) t = extend(qa, da, db, a, b);
        else t = extend(qb, db, da, b, a);

        if (t <= 10) return t;
        if ( ++ step == 10) return -1;
    }

    return -1;
}

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

    int t = bfs();
    if (t == -1) puts("NO ANSWER!");
    else cout << t << endl;

    return 0;
}

代码思路

1. 初始化: 分别将A和B放入两个队列，并在对应的哈希表中记录它们到起点的距离（初始为0）。
2. 扩展状态: 定义一个extend函数，该函数会遍历当前队列中的所有字符串，尝试应用所有规则进行扩展，并记录新状态的步数。如果在扩展过程中发现目标状态，则返回步数；否则将新状态加入队列，并在哈希表中标记其距离。
3. 双向BFS: 同时从A和B出发进行BFS，每一轮交替扩展两个队列，直到找到交集或者达到最大步数限制。
4. 结果判断: 如果在10步之内找到了B，返回步数；否则输出"No Answer!"。

改进思路

• 优化内存使用: 当队列中的元素数量变得非常大时，可以考虑使用迭代器或其他方式避免存储所有中间状态，特别是在字符串长度或规则数量很大的情况下。
• 剪枝策略: 在扩展状态时，可以添加更多的剪枝条件来减少不必要的搜索，例如当从A扩展的状态数目远大于从B扩展的状态数目时，可以优先处理从B扩展的情况，反之亦然，这样可以更快地接近交汇点。
• 利用规则特性: 如果规则之间存在某种特定关系（如某些规则是其他规则的子串），可以通过预处理优化规则应用逻辑，减少不必要的字符串比较。
• 并行处理: 对于大规模问题，可以考虑使用多线程或多进程并行执行BFS的扩展步骤，以加速搜索过程。