理想路径——双向BFS

题目

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

解题思路

方法是从终点开始倒着BFS，得到每个结点 i 到终点的最短距离d[i]。然后直接从起点开始走，但是每次到达一个新结点时要保证d值恰好减少1,直到到达终点，这样得到的一定是一条最短路。

有了上述结论，可以这样解决：直接从起点开始按照上述规则走，如果有多种走法，选择颜色字典序最小的走；如果有多条边的颜色字典序都最小，则记录所有这些边的终点，走下一步时要考虑从所有这些点出发的边。这实际上是又做了一次BFS，因此时间复杂度仍为 O(m)。

代码实现

#include<stdio.h>
#include<iostream>
#include<algorithm>
#include<cstring>
#include<vector>
#include<queue>
using namespace std;

const int maxn = 100000 + 10;
vector<int>G[maxn];
vector<int>C[maxn];
int n, m,vis[maxn], d[maxn], ans[maxn];        //d保存距离，ans保存最小距离

void init()
{
    int x, y;
    int tmp;
    memset(vis, 0, sizeof(vis));
    memset(d, 0, sizeof(d));
    memset(ans, 0, sizeof(ans));
    for (int i = 0; i <=n; i++)  G[i].clear();
    for (int i = 0; i <= n; i++)  C[i].clear();
    for (int i = 0; i < m; i++)
    {
        cin >> x >> y;
        G[x].push_back(y); G[y].push_back(x);
        cin >> tmp;
        C[x].push_back(tmp); C[y].push_back(tmp);
    }
}

void bfs1()    //进行距离的遍历，得到d数组
{
    memset(d, -1, sizeof(d));
    queue<int>q;
    d[n] = 0;
    q.push(n);
    while (!q.empty())
    {
        int u = q.front(); q.pop();
        int sz = G[u].size();
        for (int i = 0; i < sz; i++)
        {
            int v = G[u][i];
            if (d[v] == -1)
            {
                d[v] = d[u] + 1;
                q.push(v);
            }
        }
    }
    return;
}

void bfs2()    //对颜色进行排序，并保存颜色
{
    memset(vis, 0, sizeof(vis));
    queue<int>q;
    q.push(1);
    while (!q.empty())
    {
        int u = q.front(); q.pop();
        if (d[u] == 0)  return;
        int sz = G[u].size();
        int mm = -1;
        for (int i = 0; i < sz; i++)    
        {
            int v = G[u][i];
            if (d[v] == d[u] - 1)
            {
                if (mm == -1)  mm = C[u][i];
                else  mm = min(mm, C[u][i]);
            }
        }
        int t = d[1] - d[u];
        if (ans[t] == 0)  ans[t] = mm;
        else  ans[t] = min(ans[t], mm);

        for (int i = 0; i < sz; i++)   //将所有同时满足条件的节点加入队列，并同时进行bfs
        {
            int v = G[u][i];
            if (vis[v] == false && d[v] == d[u] - 1 && C[u][i] == mm)
            {
                q.push(v);
                vis[v] = true;
            }
        }
    }
    return;
}

int main()
{
    while (scanf("%d%d",&n,&m) == 2)
    {
        init();
        bfs1();
        bfs2();
        printf("%d
", d[1]);
        for (int i = 0; i < d[1]; i++)
        {
            if (i)  printf(" ");
            printf("%d", ans[i]);
        }
        printf("
");
    }
    return 0;
}

参考链接：https://blog.csdn.net/cfarmerreally/article/details/52128440