UVa 1599 (字典序最小的最短路) Ideal Path

题意：

给出一个图(图中可能含平行边，可能含环)，每条边有一个颜色标号。在从节点1到节点n的最短路的前提下，找到一条字典序最小的路径。

分析：

首先从节点n到节点1倒着BFS一次，算出每个节点到节点n个最短距离d_i

然后从节点1开始再一次BFS，在寻找下一个节点时，必须满足下一个节点v满足对于当前节点u，有d_u = d_v + 1，这样才能保证在最短路上。

在这个条件下还要满足v的颜色编号是最小的。因为可能有多个颜色相同的最小编号，所以这些节点都要保留下来。

图的表示方式：这里如果再用往常的邻接表发现不适用了，所以G[u]中保存的与u邻接的edges中边的编号。

 #include <cstdio>
 #include <vector>
 #include <cstring>
 #include <queue>
 #include <algorithm>
 using namespace std;

 const int maxn =  + ;
 const int INF =  + ;

 struct Edge
 {
     int u, v, c;
     Edge(int u=, int v=, int c=):u(u), v(v), c(c) {}
 };

 vector<Edge> edges;
 vector<int> G[maxn];

 void AddEdge(int u, int v, int c)
 {
     edges.push_back(Edge(u, v, c));
     int index = edges.size() - ;
     G[u].push_back(index);
 }

 int n, d[maxn];
 bool vis[maxn];
 vector<int> ans;

 void rev_bfs()
 {
     memset(vis, , sizeof(vis));
     queue<int> q;
     q.push(n-);
     vis[n-] = true;
     d[n-] = ;

     while(!q.empty())
     {
         int u = q.front(); q.pop();
         for(int i = ; i < G[u].size(); ++i)
         {
             int e = G[u][i];
             int v = edges[e].v;
             if(!vis[v])
             {
                 vis[v] = true;
                 d[v] = d[u] + ;
                 q.push(v);
             }
         }
     }
 }

 void bfs()
 {
     memset(vis, , sizeof(vis));
     vis[] = true;
     ans.clear();

     vector<int> next;
     next.push_back();
     for(int i = ; i < d[]; ++i)
     {
         int min_color = INF;
         for(int j = ; j < next.size(); ++j)
         {
             int u = next[j];
             for(int k = ; k < G[u].size(); ++k)
             {
                 int e = G[u][k];
                 int v = edges[e].v;
                 if(d[u] == d[v] + )
                     min_color = min(min_color, edges[e].c);
             }
         }
         ans.push_back(min_color);

         vector<int> next2;
         for(int j = ; j < next.size(); ++j)
         {
             int u = next[j];
             for(int k = ; k < G[u].size(); ++k)
             {
                 int e = G[u][k];
                 int v = edges[e].v;
                 if(!vis[v] && d[u] == d[v] +  && edges[e].c == min_color)
                 {
                     vis[v] = true;
                     next2.push_back(v);
                 }
             }
         }
         next = next2;
     }

     printf("%d\n%d", d[], ans[]);
     for(int i = ; i < ans.size(); ++i) printf(" %d", ans[i]);
     puts("");
 }

 int main()
 {
     //freopen("in.txt", "r", stdin);
     int m, u, v, c;
     while(scanf("%d%d", &n, &m) == )
     {
         edges.clear();
         for(int i = ; i < n; ++i) G[i].clear();
         while(m--)
         {
             scanf("%d%d%d", &u, &v, &c);
             if(u == v) continue;    //最短路中一定不含环
             AddEdge(u-, v-, c);
             AddEdge(v-, u-, c);
         }

         rev_bfs();
         bfs();
     }

     return ;
 }

代码君