另类bfs建图--求到目标地坐公交的最小换乘次数

题目

题目解析

建立如图：不同颜色的连接代表不同公交车

• 由于是权值为1的图(所以一般想到用bfs求最短路径)，虽然单看各个站点构成的图十分复杂。
• 但由于这个不是直接记录两个站点间的最短距离，而是记录到达终点最少的车辆换乘次数，所以我们以乘坐一辆公交车作为bfs的一步选择，每次通过遍历站点对应的各个公交车将所有点走遍，这就相当于一次选择。为防止形成环的死循环，我们应该用 visit 标记每次访问过的站点(实际上肯定要用它标记乘坐过的公交车)，防止无限循环。如果通过 visit 标记站点，则会出现大量不必要的判断，毕竟已经选过的公交车，再次选择这个公交车的结果肯定是多余的。，不信我后面为你试验试验🤣

做题细分步骤

1. 通过给出的数据建图：该题是通过不同的站点可乘坐的公交车建立哈希表来实现建图，你可以看作你在站点等公交时看到的等车牌，上面记录着这个站点可以坐哪些公交。

 //通过哈希表映射出各个站点所能坐的公交车(建图)，根据每个站点以及该图进行扩散
        unordered_map<int,vector<int>>mmp;
        for(int i=0;i<routes.size();i++)
            for(const int p:routes[i])
                mmp[p].push_back(i);

2. 根据图的关系bfs：

queue<int>Q;Q.push(source);
        unordered_set<int>visit;
        int buses = 0;
        while(!Q.empty()){
            for(int i = Q.size();i>0;i--){
               const int t = Q.front();Q.pop();
               //开始扩散
                vector<int>& q = mmp[t];
//外层确定此次的步数(即从该站坐哪路车)，内层记录选择一坐某路车后的下一个站点可能(这样就会超时，因为会出现大量重复的判断，必须用visit记录每次已经乘坐过的巴士，而不是去记录走过的站点)
                for(const int h:q){
                //检查是否已经乘坐过该公交
                    if(!visit.count(h))
                        for(const int s:routes[h]){
                            if(s==t)continue;
                            if(s==target)return buses+1;
                            Q.push(s);
                        }
                    visit.insert(h);
                }
            }
            buses++;
        }
        return -1;

3. 汇总代码得出答案：

效率尚可：
不知为啥，双向bfs效率反而更低了，所以没用了🤣

class Solution {
public:
    int numBusesToDestination(vector<vector<int>>& routes, int source, int target) {
        if(source==target)return 0;
        //通过哈希表映射出各个站点所能坐的公交车(建图)，根据每个站点以及该图进行扩散
        unordered_map<int,vector<int>>mmp;
        for(int i=0;i<routes.size();i++)
            for(const int p:routes[i])
                mmp[p].push_back(i);
        queue<int>Q;Q.push(source);
        unordered_set<int>visit;
        int buses = 0;
        while(!Q.empty()){
            for(int i = Q.size();i>0;i--){
               const int t = Q.front();Q.pop();
               //开始扩散
                vector<int>& q = mmp[t];
//外层确定此次的步数(即从该站坐哪路车)，内层记录选择一坐某路车后的下一个站点可能(这样就会超时，因为会出现大量重复的判断，必须用visit记录每次已经乘坐过的巴士，而不是去记录走过的站点)
                for(const int h:q){
                    if(!visit.count(h))
                        for(const int s:routes[h]){
                            if(s==t)continue;
                            if(s==target)return buses+1;
                            Q.push(s);
                        }
                    visit.insert(h);
                }
            }
            buses++;
        }
        return -1;
    }
};

如果是通过visit记录每次走过的站点，直接超时！

class Solution {
public:
    int numBusesToDestination(vector<vector<int>>& routes, int source, int target) {
        if(source==target)return 0;
        //通过哈希表映射出各个站点所能坐的公交车(建图)，根据每个站点以及该图进行扩散
        unordered_map<int,vector<int>>mmp;
        for(int i=0;i<routes.size();i++)
            for(const int p:routes[i])
                mmp[p].push_back(i);
        queue<int>Q;Q.push(source);
        unordered_set<int>visit;
        visit.insert(source);
        int buses = 0;
        while(!Q.empty()){
            for(int i = Q.size();i>0;i--){
               const int t = Q.front();Q.pop();
               //开始扩散
                vector<int>& q = mmp[t];
//外层确定此次的步数(即从该站坐哪路车)，内层记录选择一坐某路车后的下一个站点可能
                for(const int h:q){
                    for(const int s:routes[h]){
                        if(!visit.count(s)){
                            if(s==target)return buses+1;
                            visit.insert(s);
                            Q.push(s);
                        }
                    }
                }
            }
            buses++;
        }
        return -1;
    }
};