算法提高-搜索-双向广搜 A*

双向广搜

双向广搜一般用于起点和终点可以同时往中间搜，具体每次扩展哪个取一个平衡，哪边少扩展哪边

AcWing 190. 字串变换

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

using namespace std;
const int N = 6;
int n;
string a[N],b[N];
// 扩展函数
// 参数：扩展的队列，到起点的距离，到终点的距离，规则，规则
//返回值：满足条件的最小步数
int extend(queue<string>& q, unordered_map<string,int>& da, unordered_map<string, int>& db,
        string a[], string b[]){
    // 取出队头元素
    string t = q.front();
    q.pop();

    for(int i = 0; i < t.size(); i ++)  // t从哪里开始扩展
        for(int j = 0; j < n; j ++) // 枚举规则
            //如果t这个字符串的一段= 规则，比如= xyz，才可以替换
            if(t.substr(i, a[j].size()) == a[j]){
                // 变换之后的结果state:前面不变的部分+ 变化的部分 + 后面不变的部分
                // 比如abcd ，根据规则abc--> xu，变成 xud，这里的state就是xud
                string state = t.substr(0,i) +b[j] + t.substr(i + a[j].size());
                // state状态是否落到b里面去，两个方向会师，返回最小步数
                if(db.count(state)) return da[t] + 1 + db[state];
                // 如果该状态之前已扩展过，
                if(da.count(state)) continue;
                da[state] = da[t] + 1;
                q.push(state);
            }
    return 11;

}
// 从起点和终点来做bfs
int bfs(string A, string B){
    queue<string> qa, qb; // 两个方向的队列
    //每个状态到起点的距离da（哈希表），每个状态到终点的距离db哈希表
    unordered_map<string, int> da, db; 
    // qa从起点开始搜，qb从终点开始搜
    qa.push(A), da[A] = 0; // 起点A到起点的距离为0
    qb.push(B), db[B] = 0; // 终点B到终点B的距离为0

    // qa和qb都有值，说明可以扩展过来，否则说明是不相交的
    while(qa.size() && qb.size()){
        int t; // 记录最小步数
        // 哪个方向的队列的长度更小一些，空间更小一些，从该方向开始扩展，
        // 时间复杂度比较平滑,否则有1个点会超时
        if(qa.size() <= qb.size()) 
            t = extend(qa, da, db, a, b);
        else t = extend(qb, db, da, b, a);
        // 如果最小步数在10步以内

        if( t <= 10) return t;
    }

    return 11; // 如果不连通或者最小步数>10，则返回大于10的数

}

int main(){
    string A, B;
    cin >> A >> B;
    // 读入扩展规则，分别存在a数组和b数组
    while( cin >> a[n] >> b[n]) n ++;
    int step = bfs(A,B);
    if(step > 10) puts("NO ANSWER!");
    else cout << step << endl;
}

A*

启发函数 相当于在搜索的过程在做贪心的选择

AcWing 179. 八数码

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

using namespace std;


int f(string state)//启发函数
{
    int res = 0;
    for (int i = 0; i < state.size(); i ++ )
    {
        if (state[i] != 'x')
        {
            int t = state[i] - '1';
            res += abs(i / 3 - t / 3) + abs(i % 3 - t % 3);//当前状态到目标状态的估计距离 ，只要这个估价函数算出来的估计距离小于实际距离即可
        }
    }
    return res;
}

string bfs(string start)
{
    int dx[4] = {-1, 0, 1, 0}, dy[4] = {0, 1, 0, -1};
    char op[4] = {'u', 'r', 'd', 'l'};
    
    string end = "12345678x";
    unordered_map<string, int> dist;
    unordered_map<string, pair<string, char>> pre;
    
    //优先处理 起点到当前状态的实际距离 + 当前状态到目标状态的估计距离最小的点
    priority_queue<pair<int ,string>, vector<pair<int, string>>, greater<pair<int, string>>> heap;
    dist[start] = 0;//记录起点到当前状态的距离， f启发函数计算出来的是当前状态到目标状态的距离
    
    heap.push({0 + f(start), start});//heap里面的pair的first是 :起点到当前状态的实际距离 + 当前状态到目标状态的估计距离最小的点

    while (heap.size())
    {
        auto t = heap.top();
        heap.pop();
        
        string state = t.second;
        
        if (state == end) break;
        
        int step = dist[state];
        
        int x, y;
        for (int i = 0; i < state.size(); i ++ )
        {
            if (state[i] == 'x')
            {
                x = i / 3, y = i % 3;//找到x的位置，状态的转移就是根据它来的，同时这个坐标的映射很巧妙
                break;
            }
            
        }
        
        string source = state;
        for (int i = 0; i < 4; i ++ )
        {
            int a = x + dx[i], b = y + dy[i];
            
            if (a >= 0 && a < 3 && b >= 0 && b < 3)
            {
                swap(state[x * 3 + y], state[a * 3 + b]);
                if (!dist.count(state) || dist[state] > step + 1)
                {
                    dist[state] = step + 1;
                    pre[state] = {source, op[i]};
                    heap.push({dist[state] + f(state), state});
                }
                swap(state[x * 3 + y], state[a * 3 + b]);
                
                            
            //我觉得 dfs 是否需要恢复现场那一点 y 总没有讲到本质上,
            //y 总最后总结的是: 内部搜索不需要恢复现场, 外部搜索需要回复现场
            //我觉得根搜索的类型无关, 主要看具体的实现手段, 不恢复现场意味着系统帮我们来维护结点状态, 恢复现场意味着自己来维护结点的状态
            //自己维护结点状态指的是搜索一个结点 u 的所有邻接点 v 的时候, 点 u 是固定的, 不能变化的, 这是显而易见的
            
            
            
            //这是外部状态之间的转换，要回溯回上一个状态，继续遍历上一个状态可以到达的其他状态
            }
            

            
        }
    }
    
    
    string res;
    while(end != start)
    {
        res += pre[end].second;
        end = pre[end].first;//这就是为什么要记录当前状态是由哪个状态转移过来的
    }
    reverse(res.begin(), res.end());//记住reverse不是res.reverse!!。。
    return res;    
}

int main()
{
    string g, c, seq;
    while (cin >> c)//神奇的输入方法
    {
        g += c;
        if (c != "x") seq += c;
    }

    int t = 0;
    for (int i = 0; i < seq.size(); i ++ )
        for (int j = i + 1; j < seq.size(); j ++ )
            if (seq[i] > seq[j])
                t ++ ;

    if (t % 2) puts("unsolvable");
    else cout << bfs(g) << endl;

    return 0;
}

AcWing 178. 第K短路

这题遇到了一个bug，cout输出bfs就是-1，printf就可以正确输出14

#include <iostream>
#include <cstring>
#include <queue>
using namespace std;

typedef pair<int, int> PII;
typedef pair<int, PII> PIII;
#define x first
#define y second

const int N = 1010, M = 2e4 + 10;

int h[N], rh[N], e[M], ne[M], w[M], idx;
int dist[N];//记录终点到其他点的距离，当做a*的启发函数的估计值
int cnt[N];
bool st[N];

int n, m;
int S, T, K;

void add(int h[], int a, int b, int c)//这里要给图和图的反向图建邻接表，因此要多传入一个h[]才知道建的是哪个图的表
{
    e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx ++ ; 
}

void astar_djkstra()//启发函数求的一个点到终点的估计距离即我们预处理用djkstra求的反向图到各点的实际距离
{
    priority_queue<PII, vector<PII>, greater<PII>> heap;//djkstra堆优化版本
    heap.push({0, T});
    
    memset(dist, 0x3f, sizeof dist);
    dist[T] = 0;
    
    while (heap.size())
    {
        auto t = heap.top();
        heap.pop();
        
        int ver = t.y;
        if (st[ver]) continue;//每个点只需要用它来松弛一次它周围的点到源点的距离，这里的源点是终点T
        st[ver] = true;
        
        for (int i = rh[ver]; ~i; i = ne[i])//~i表示i != -1
        {
            int j = e[i];
            if (dist[j] > dist[ver] + w[i]) 
            {
                dist[j] = dist[ver] + w[i];
                heap.push({dist[j], j});
            }
        }
    }
}

int bfs()
{
    priority_queue<PIII, vector<PIII>, greater<PIII>> heap_astar;
    heap_astar.push({0 + dist[S], {0, S}});
    
    while (heap_astar.size())
    {
        auto t = heap_astar.top();
        heap_astar.pop();
        
        int distance = t.second.first;
        int ver = t.second.second;
        
        cnt[ver] ++ ;//出队一次，记录一次，出队K次即最短
        if (cnt[T] == K) return distance;
        
        for (int i = h[ver]; ~i; i = ne[i])
        {
            int j = e[i];
            if(cnt[j] < K)
            {
                heap_astar.push({distance + w[i] + dist[j], {distance + w[i], j}});
                //bfs本质还是暴搜，不用判断直接存进队列就行
                //之前的a*只是减小我们搜索的范围罢了，
            }
        }
    }
    return -1;
}

int main()
{
    scanf("%d%d", &n, &m);
    memset(h, -1, sizeof h);
    memset(rh, -1, sizeof h);//这就是为啥遍历的到时候遍历到~i
    
    for (int i = 0; i < m; i ++ )
    {
        int a, b, w;
        scanf("%d%d%d", &a, &b, &w);
        add(h, a, b, w);
        add(rh, b, a, w);
    }
    
    
    scanf("%d%d%d", &S, &T, &K);
    if (S == T) K ++ ;//题目说了必须包含一条边，如果起点和终点重合那么K得加1
    
    astar_djkstra();
    cout << bfs() << endl;
    //printf("%d\n", bfs());//相当于运行了两次bfs，当然会输入0了
    return 0;
}