LeetCode 公交路线（广度优先搜索）

我们有一系列公交路线。每一条路线 routes[i] 上都有一辆公交车在上面循环行驶。例如，有一条路线 routes[0] = [1, 5, 7]，表示第一辆 (下标为0) 公交车会一直按照 1->5->7->1->5->7->1->… 的车站路线行驶。

假设我们从 S 车站开始（初始时不在公交车上），要去往 T 站。 期间仅可乘坐公交车，求出最少乘坐的公交车数量。返回 -1 表示不可能到达终点车站。

示例:

输入: 
routes = [[1, 2, 7], [3, 6, 7]]
S = 1
T = 6
输出: 2
解释: 
最优策略是先乘坐第一辆公交车到达车站 7, 然后换乘第二辆公交车到车站 6。

说明:

1 <= routes.length <= 500.
1 <= routes[i].length <= 500.
0 <= routes[i][j] < 10 ^ 6.

$思路分析：$这是一道典型的最短路径搜索题，一般都是使用深度优先搜索或者广度优先搜索。蛋试这道题有两个难点，一个是测试的数据量比较大，所以算法的时间复杂度需要尽可能的低，第二是routes信息是放在两层vector容器中，进行搜索时比较复杂，需要优化。

首先我们将vector> 二维vector容器转换为vector> 容器，这样方便查找线路中是否含有某个车站。
并且使用unordered_set容器haveVisitedCar和haveVisitedStop分别记录已经访问过的公交车以及已经访问过的车站。

class Solution {
public:
    unordered_set<int> haveVisitedCar, haveVisitedStop;
    int numBusesToDestination(vector<vector<int>>& routes, int S, int T) {
        if (S == T){//特殊情况，已在终点
            return 0;
        }
        //将`vector>` 二维vector容器转换为`vector>` 容器，这样方便查找线路中是否含有某个车站
        vector<unordered_set<int>> myRoutes;
        for (auto &route : routes){
            myRoutes.push_back(unordered_set<int>(route.begin(), route.end()));
        }
        int minStep = 1;//最少需要乘坐的公交车数
        queue<int> myQue;//广度优先搜索辅助队列
        myQue.push(S);
        haveVisitedStop.insert(S);//标记站点已经访问
        while (!myQue.empty()){
            //将当前队列中所有元素都下寻找一个公交站
            for (int i = (int)myQue.size(); i > 0; --i){
                int front = myQue.front();
                myQue.pop();
                unordered_set<int> canToSet;//front能够到达的站点
                findCar(myRoutes, front, canToSet);
                if (canToSet.count(T)){//如果能知道到达T，说明已经找到了结果
                    return minStep;
                }
                //将为访问过的站点放入队列
                for (auto cit = canToSet.cbegin(); cit != canToSet.cend(); ++cit){
                    if (haveVisitedStop.count(*cit) == 0){
                        myQue.push(*cit);
                        haveVisitedStop.insert(*cit);
                    }
                }
            }
            minStep += 1;
        }
        return -1;
    }
    //搜索S能够到达的站点放入canToSet
    void findCar(vector<unordered_set<int>>& myRoutes, int S, unordered_set<int> &canToSet){
        for (int index = (int)myRoutes.size() - 1; index >= 0; --index){
            //这条线路需要包括S，并且这条线路之前没有访问过
            if (myRoutes[index].count(S) && haveVisitedCar.count(index) == 0){
                haveVisitedCar.insert(index);//当前标记访问
                canToSet.insert(myRoutes[index].begin(), myRoutes[index].end());
            }
        }
    }
};

蛋试上面的程序不稳地，很多时候都会超时。
因为该算法设计到大量的查找、插入操作。下面将vector> 二维vector容器转换为unordered_map> 容器，表示一个站点所涉及的线路。

class Solution {
public:
    int numBusesToDestination(vector<vector<int>>& routes, int S, int T){
        if(S == T){
            return 0;
        }
        queue<int> myQue;//广度优先搜索辅助队列
        myQue.push(S);
        unordered_map<int, vector<int>> hashMap;//hashMap[station]记录所有线路中存在station这个站点的线路下标
        int minSteps = 1, routesSize = (int)routes.size();//minSteps为最少需要乘坐的公交车数量
        vector<bool> visitedRoute(routesSize, false);//标记已经访问过的线路
        //构建hashMap信息，统计每个站点出现的线路
        for(int i = 0; i < routesSize; ++i){
            for (const auto &station : routes[i]){
                hashMap[station].push_back(i);
            }
        }
        while(!myQue.empty()){
            //将当前队列中所有的站点都向下寻找一条线路
            for (int i = (int)myQue.size(); i > 0; --i){
                int frontStation = myQue.front();
                myQue.pop();
                //遍历frontStation这个站点能够到达的所有线路
                for(const auto &routeIndex : hashMap[frontStation]){
                    if(!visitedRoute[routeIndex]){//这条线路必须是未访问过的
                        visitedRoute[routeIndex] = true;
                        //遍历routeIndex这条线路中的所有站点
                        for(const auto &station : routes[routeIndex]){
                            if(station == T){//到达了目的地
                                return minSteps;
                            }
                            myQue.push(station);
                        }
                    }
                }
            }
            minSteps++;//实际上size就是这一层的多少
        }
        return -1;//无法到达
    }
};

这到题的关键就在于如何处理线路信息，从而减少搜索车站、线路的次数。