UVA ~ 1599 ~ Ideal Path （非简单图 + 逆向BFS）

题意：给一个n个点m条边（2≤n≤100000,1≤m≤200000）的无向图，每条边上都涂有一种颜色。求从结点1到结点n的一条路径，使得经过的边数尽量少，在此前提下，经过边的颜色序列的字典序最小。一对结点间可能有多变，一条边可能连接两个相同的结点。输入保证结点1可以到达结点n。颜色为1~10^9的整数。

【分析】

首先回顾一下第3章中介绍的“字典序”。对于字符串来说，字典序就是在字典里的顺序。例如，ab在cd的前面，cde在a的后面，abcd在abcde的前面。这个定义是可以扩展到序列：序列（1,2）在序列（3,4,5）的前面，（4,6,5）在（4,5）的后面。

抛开字典序不谈，本题只是一个普通的最短路问题，可以用BFS解决。但是之前“记录父节点”的方法已经不适用了，因为这样打印出来的路径并不能保证字典序最小。怎么办呢？

事实上，无需记录父节点也能得到最短路，方法是从终点开始“倒着”BFS，得到每个结点i到终点的距离d[i]，然后直接从起点开始走，但是每次到达一个新结点时要保证d值恰好减少1（如果有多个选择则可以随便走），直到到达终点。可以证明（想一想，为什么）：这样走过的路径一定是一条最短路。

有了上述结论，本题就不难解决了：直接从起点按照上述规则走，如果有多种走法，选颜色字典序最小的走；如果有多条边的颜色字典序都是最小，则记录所有这些边的终点，走下一步时要考虑是所有从这些点出发的边。聪明的读者应该已经看出来了：这实际上是又做了一次BFS，因此时间复杂度仍为O（m）。其实本题也可以只进行一次BFS，不过要从终点开始逆向进行，有兴趣的读者可以自行研究。

以上内容来自《算法竞赛入门经典》

补充：由于图很大，所以我们不能用邻接矩阵保存了，需要用到邻接表的方式。第二次BFS的时候，不需要用到队列。因为每次我们要保留可以到达的下一层中color最小的那些点，然后以这些点在往下面走，所以我们用两个vector保存点的编号模拟即可。

#include
using namespace std;
const int MAXN = 100005;
const int INF = 1000000005;
int n, m;
vector ans;
struct Edge
{
    int u, v, c;
    Edge(int u = 0, int v = 0, int c = 0): u(u), v(v), c(c) {}
};
vector edges;
vector G[MAXN];
void init()
{
    ans.clear();
    edges.clear();
    for (int i = 0; i <= n; i++) G[i].clear();
}
void AddEdge(int u, int v, int c)
{
    edges.push_back(Edge(u, v, c));
    int idx = edges.size() - 1;
    G[u].push_back(idx);
}

int d[MAXN];
bool vis[MAXN];
void revbfs()
{
    memset(vis, 0, sizeof(vis));
    vis[n] = true; d[n] = 0;
    queue Q;
    Q.push(n);
    while (!Q.empty())
    {
        int u = Q.front(); Q.pop();
        for (int i = 0; i < G[u].size(); i++)
        {
            Edge e = edges[G[u][i]];
            if (!vis[e.v])
            {
                vis[e.v] = true;
                d[e.v] = d[u] + 1;
                Q.push(e.v);
            }
        }
    }
}
void bfs()
{
    memset(vis, 0, sizeof(vis));
    vis[1] = true;

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

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

}
int main()
{
    while (~scanf("%d%d", &n, &m))
    {
        init();
        while (m--)
        {
            int u, v, c;
            scanf("%d%d%d", &u, &v, &c);
            AddEdge(u, v, c);
            AddEdge(v, u, c);
        }
        revbfs();
        bfs();
        printf("%d\n", ans.size());
        for (int i = 0; i < ans.size(); i++)
        {
            printf("%d", ans[i]);
            if (i != ans.size()-1) printf(" ");
            else printf("\n");
        }
    }

    return 0;
}
/*
4 6
1 2 1
1 3 2
3 4 3
2 3 1
2 4 4
3 1 1
*/