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 = 100000 + 10;
const int INF = 1000000000 + 10;

struct Edge
{
    int u, v, c;
    Edge(int u=0, int v=0, int c=0):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() - 1;
    G[u].push_back(index);
}

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

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

    while(!q.empty())
    {
        int u = q.front(); q.pop();
        for(int i = 0; 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] + 1;
                q.push(v);
            }
        }
    }
}

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

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

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

    printf("%d
%d", d[0], ans[0]);
    for(int i = 1; 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) == 2)
    {
        edges.clear();
        for(int i = 0; i < n; ++i) G[i].clear();
        while(m--)
        {
            scanf("%d%d%d", &u, &v, &c);
            if(u == v) continue;    //最短路中一定不含环
            AddEdge(u-1, v-1, c);
            AddEdge(v-1, u-1, c);
        }

        rev_bfs();
        bfs();
    }

    return 0;
}