UVa 1599 理想路径（反向BFS 求最短路径 ）

题意：

给定一个有重边有自环的无向图，n个点（2 <= n <= 100000）, m条边(1 <= m <= 200000)， 每条边有一个权值， 求从第一个点到n的最少步数， 如果最少步数相同有多条路径， 那么输出权值字典序最小的一条。

分析：

用BFS解决最短路问题， 可以先从终点BFS， 求出每个点到终点的最短距离。 那么最少步数就是起点的最短距离， 最短路径就是从起点每次向最短距离比自己少1的顶点移动（如果有多个则可以随便走）， 这样就可以保证走的是最短路径， 如果一开始我们是从起点BFS， 那么这样则不能保证走的是通往终点的最短路径。然后我们就可以从起点出发， 循环最短距离次， 每次选择字典序最少的走，  如果有多个字典序相同则选择多个， 直到走完最短距离， 就可以得出答案。 注意两次BFS都需要添加标记， 不然重边很可能就会导致TLE。

 #include <bits/stdc++.h>
 using namespace std;
 const int maxm = 1e7;
 const int maxn = 1e6 + ;
 const int inf = 1e9;
 struct Node{
     int v,col,next;
     Node():v(),col(),next(){}
 };
 struct ele{
     int v;
     int dist;
     ele(int v, int dist):v(v),dist(dist){}
 };

 Node edge[maxn];
 int G[maxn], d[maxn];
 bool vis[maxn];
 int n, m, cnt;

 void build(){
     memset(G,-,sizeof(G));
         cnt = ;
         for(int i = ; i < m; i++){
             int u, v, col;
             scanf("%d %d %d", &u, &v, &col);
             if(u == v) continue;
             edge[cnt].v = v;
             edge[cnt].col = col;
             edge[cnt].next = G[u];
             G[u] = cnt++;
             edge[cnt].v = u;
             edge[cnt].col = col;
             edge[cnt].next = G[v];
             G[v] = cnt++;
         }
 }

 void revbfs(){
     fill(d,d+maxn, inf);
     memset(vis,,sizeof(vis));
     queue<ele> q;
     q.push(ele(n,));
     d[n] = ;
     vis[n] = ;
     while(!q.empty()){
         ele u = q.front(); q.pop();
         d[u.v] = u.dist;
         for(int i = G[u.v]; i != -; i = edge[i].next){
             int v = edge[i].v;
             if(d[v] < u.dist +  || vis[v]){
                 continue;
             }
             q.push(ele(v,u.dist+));
             vis[v] = ;
         }
     }
 }
 void bfs(){
     vector<int> path;
         memset(vis,,sizeof(vis));
         vis[] = ;
         vector<int> next;
         next.push_back();
         for(int i = ; i < d[]; i++){//the essential minimum step
             int min_col = inf;
             for(int j = ; j < next.size(); j++){
                 int u = next[j];
                 for(int k = G[u]; k != -; k = edge[k].next){
                     int v = edge[k].v;
                     if(d[u] == d[v] + )
                         min_col = min(min_col,edge[k].col);
                 }
             }
             //find out the minimum color
             path.push_back(min_col);

             vector<int> next2;
             for(int j = ; j < next.size(); j++){
                 int u = next[j];
                 for(int k = G[u]; k != -; k= edge[k].next){
                     int v = edge[k].v;
                     if(d[u] == d[v] +  && !vis[v] && edge[k].col == min_col){
                         vis[v] = ;
                         next2.push_back(v);
                     }
                 }
             }
             next = next2;
         }

         printf("%d\n%d",(int)path.size(),path[]);
         for(int i = ; i < path.size(); i++){
             printf(" %d",path[i]);
         }
         puts("");
 }
 int main(){
     freopen("1.txt","r",stdin);
     while(~scanf("%d %d", &n, &m)){
         build();
         revbfs();//反向bfs求出终点到每个点的最短距离
         bfs();
     }
      printf("%.3f",(double)clock()/CLOCKS_PER_SEC);
     return ;
 }