最短路径还原的实现方法

例题链接：CF20C
我们通过了Dijkstra算法或者SPFA算法等等获得了最短路径，记为 d[ k ]，这就出现了一个逆向问题，怎么去还原这条路径。

题目中给了我们一张图，然后要我们求 点1 到 点n 的具体某一条最短路径。我们知道，如果一条最短路径里面包含 i-1 和 i 这两个点，i-1 到 i 的边权值为 w 。则必然有关系式：

d[ i ]=d[ i-1 ]+w

所以，我们可以根据这条规则，通过深度优先搜索来确定最短路径。需要注意的点是，由于图可以带有环，所以必须标记哪些点已经被标记为最短路径；另外，在某条路径不成立时，需要回溯路径还原现场。

这样，从n开始，我们第一次搜索到 1 时，被标记的点就是一条合题的最短路径，就可以结束程序输出了。

例题代码如下：

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<vector>
#include<queue>
#include<cstring>
#define maxn 100005
using namespace std;
typedef pair<long long,int> P;
long long INF=1000000000000;
struct imf
{
    int to,value;
};
vector<imf>Q[maxn];
long long d[maxn];
priority_queue<P,vector<P>,greater<P> >G;
vector<int>ans;
int k[maxn]={0};
void dijkstra()
{
    G.push(make_pair(0,1));
    while(!G.empty())
    {
        P tmp=G.top();
        G.pop();
        if(d[tmp.second]<tmp.first)continue;
        for(int i=0;i<Q[tmp.second].size();i++)
        {
            imf s=Q[tmp.second][i];
            if(d[s.to]>tmp.first+s.value)
            {
                d[s.to]=tmp.first+s.value;
                G.push(make_pair(d[s.to],s.to));
            }
        }
    }
}
int dsf(int go)
{
    if(go==1)
    {
        return 1;
    }
    for(int i=0;i<Q[go].size();i++)
    {
        imf e=Q[go][i];
        if(k[e.to])continue;
        if(d[e.to]==d[go]-e.value)
        {
            ans.push_back(e.to);
            k[e.to]=1;
            int check=dsf(e.to);
            if(check==0){ans.pop_back();k[e.to]=0;}
            else return 1;
        }
    }
    return 0;
}
int main()
{
    int n,m;
    scanf("%d %d",&n,&m);
    int u,v,w;
    for(int i=1;i<=m;i++)
    {
        scanf("%d %d %d",&u,&v,&w);
        Q[u].push_back((imf){v,w});
        Q[v].push_back((imf){u,w});
    }
    fill(d,d+maxn,INF);
    d[1]=0;
    dijkstra();
    ans.push_back(n);
    k[n]=1;
    int check=0;
    if(d[n]!=INF)check=dsf(n);
    if(check)
    {
        for(int i=ans.size()-1;i>=0;i--)cout<<ans[i]<<" ";
    }
    else cout<<-1;
}

如果要找出所有的最短路径，也可以用深度优先搜索来完成。具体的实现方法的细节就是，每一次搜索到 1 都输出一次答案，然后回溯即可。