BFS打印路径

#include <bits/stdc++.h>
using namespace std;

//对于一个数有三次操作 加一 减一 或者除二 
//求出从一个数转移到另一个数的最少步数
//可以用bfs求解 求从2022到1吧

int vis[100000];
int pre[100000];

int bfs(int a,int b)
{
    queue<int>qu;
    qu.push(a);
    vis[a] = 1;
    while (!qu.empty())
    {
        int nw = qu.front();
        qu.pop();
        int x = 0;
        if(nw%2==0)//为偶
        {
            x = nw/2;
            if(vis[x]==0) 
            {
                vis[x] = vis[nw]+1;
                qu.push(x);
                pre[x] = nw;
            }
        }
            
        x = nw+1;
        if(vis[x]==0) 
        {
            vis[x] = vis[nw]+1;
            qu.push(x);
            pre[x] = nw;
        }
        x = nw-1;
        if(vis[x]==0) 
        {
            vis[x] = vis[nw]+1;
            qu.push(x);
            pre[x] = nw;
        }
        if(vis[b]) return vis[b];
    }
}

void print(int a,int b)// 根据pre数组 输出路径
{
    vector<int>vi;
    int p = b;
    while (p!=a)//只要还没到终点
    {
        vi.push_back(p);
        p = pre[p];
    }
    vi.push_back(a);//加入起点
    for(int i = vi.size()-1;i>=0;i--)
    {
        cout << vi[i] <<" ";
    }
}

int main()
{
    int a,b;cin >> a >> b;//求a到b 的最少步骤
    cout << bfs(a,b)-1<<"\n";
    cout <<"路径为： ";
    print(a,b);
    return 0;
}

实际上就是pre数组的设定。

从起点到终点，就相当于很多人走迷宫，分叉特别多，然后走到最后的也就只有那一个路，但是这所有的情况还是记录下来了。而从终点到起点，就非常清晰明了了，所以直接回溯条件就可以了。

pre数组是一种常用的在搜索算法中记录路径的方法。在搜索过程中，我们需要记录下每个节点是从哪个节点转移过来的，这样在搜索完成后就可以根据pre数组从终点回溯到起点，并输出路径。

具体来说，pre数组的定义如下：假设搜索的起点为s，终点为t，pre[i]表示从起点s到i的最短路径中i的前一个节点。当搜索结束后，pre数组记录了从起点到终点的最短路径上每个节点的前一个节点。

在BFS或者Dijkstra等算法中，更新pre数组的时机是在队列中插入一个新的节点的时候，记录该节点是从哪个节点转移过来的。在DFS等算法中，更新pre数组的时机是在访问一个新的节点的时候，记录该节点是从哪个节点转移过来的。

当搜索结束后，可以通过pre数组回溯路径并输出。具体做法是从终点t开始，依次将pre数组中每个节点的前一个节点入栈，直到回溯到起点s为止，最后依次弹出栈中的元素，即可得到从起点到终点的最短路径。

#include <iostream>
#include <stack>
#include <vector>
using namespace std;

const int MAXN = 1005;

int pre[MAXN]; // pre数组，记录最短路径上每个节点的前一个节点

vector<int> G[MAXN]; // 图的邻接表表示

// BFS算法求最短路径，并记录pre数组
void bfs(int s, int t) {
    queue<int> q;
    memset(pre, -1, sizeof(pre)); // 初始化pre数组为-1
    pre[s] = s;
    q.push(s);
    while (!q.empty()) {
        int u = q.front();
        q.pop();
        for (int i = 0; i < G[u].size(); i++) {
            int v = G[u][i];
            if (pre[v] == -1) {
                pre[v] = u; // 记录最短路径上v的前一个节点是u
                q.push(v);
            }
        }
    }
}

// 利用pre数组回溯路径
void print_path(int s, int t) {
    stack<int> stk;
    stk.push(t);
    int u = pre[t];
    while (u != s) {
        stk.push(u);
        u = pre[u];
    }
    stk.push(s);
    while (!stk.empty()) {
        cout << stk.top() << " ";
        stk.pop();
    }
}

int main() {
    // 假设图的邻接表已经建好，这里不再赘述
    int s, t;
    cin >> s >> t; // 假设起点为s，终点为t
    bfs(s, t);
    print_path(s, t);
    return 0;
}