我们有一系列公交路线。每一条路线 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.
思路分析： \color{blue}思路分析：思路分析：这是一道典型的最短路径搜索题，一般都是使用深度优先搜索或者广度优先搜索。蛋试这道题有两个难点，一个是测试的数据量比较大，所以算法的时间复杂度需要尽可能的低，第二是routes信息是放在两层vector容器中，进行搜索时比较复杂，需要优化。
首先我们将vector<vector<int>> 二维vector容器转换为vector<unordered_set<int>> 容器，这样方便查找线路中是否含有某个车站。
并且使用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<int>>` 二维vector容器转换为`vector<unordered_set<int>>` 容器，这样方便查找线路中是否含有某个车站
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<int>> 二维vector容器转换为unordered_map<int, vector<int>> 容器，表示一个站点所涉及的线路。
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;//无法到达
}
};
这到题的关键就在于如何处理线路信息，从而减少搜索车站、线路的次数。
