Leetcode 815.公交路线

公交路线

1.题目描述

我们有一系列公交路线。每一条路线 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 <= 10^5.
0 <= routes[i][j] < 10 ^ 6.

2.解体思路

解题思想为图广度优先搜索(BFS),问题难点在于如何建图，如何搜索？
图的表示为G=(N,E),即结点和边组成，此题由于0 <= routes[i][j] < 10 ^ 6所以选取车站为结点不合适，那么我们可以选取公交车为结点。
算法思想：

（1）构建图结点：以公交车为结点，其中车站为属性，如下图：

（2）构建边关系：结点i与结点j之间是否能互通，可以简化为，对于i节点中存在一车站，结点j中是否存在，若存在，则互通，否者，不通。

由于0号结点与1号结点共同拥有属性7号车站，所以0，1之间互通，则用例构建邻接矩阵为：

（3）构造访问结点集合与目标结点集合

访问结点结合：记录结点是否访问，针对图中存在环的问题。
目标结点集合：目标车站所在的公交车结点集合，目标结点结合中包括当前结点，则搜索完成。

（4）BFS搜索

主要使用队列来记录可以访问的结点，找最小换乘次数，就是S->T寻找最短路径，队列中保存两个元素，结点编号以及步数，由于步数从1开始，只要是搜索到目标结点，则一定是最短路径，因为，广度优先搜索，先遍历步数1的，然后步数2，····，所以一定先找到的是步数小的。

3.代码复现

#include
class Solution {
     
public:
    int numBusesToDestination(vector<vector<int>>& routes, int S, int T) {
     
        if(S==T) return 0;
        int N=routes.size();
        for(int i=0;i<N;++i)
        {
     
            sort(routes[i].begin(),routes[i].end());  //由于后面使用二分查找，所以先排序
        }
        vector<vector<int>> graph(N);     //采用压缩存储方式
        for(int i=0;i<N;++i)
        {
     
            for(int j=i+1;j<N;++j)
            {
     
                if(connection(routes[i],routes[j]))
                {
     
                    graph[i].push_back(j);    //填充邻接矩阵
                    graph[j].push_back(i);
                }
            }
        }

        set<int> vis;   //访问结点集合
        set<int> target;    //目标结点集合
        queue<pair<int,int>> q;
        for(int i=0;i<N;++i)
        {
     
            if(binary_search(routes[i].begin(),routes[i].end(),S))
            {
     
                vis.insert(i);      //包括S车站的都为访问结点和起始点
                q.push(pair<int,int>{
     i,1});     //由于初始不在车上，所以初值设为1
            }
            if(binary_search(routes[i].begin(),routes[i].end(),T))
                target.insert(i);       //包括T车站的都为目标点
        }

        while(!q.empty())
        {
     
            int cur=q.front().first;    //当前结点编号
            int dis=q.front().second;     //当前步数
            q.pop();
            if(target.count(cur))  return dis;    //若目标点集合包括当前结点，则返回，一定最小
            for(int i=0;i<graph[cur].size();++i)
            {
     
                if(!vis.count(graph[cur][i]))    //与当前结点连通且为未访问过结点入队
                  {
     
                        q.push(pair<int,int>{
     graph[cur][i],dis+1});   //距离++
                        vis.insert(graph[cur][i]);             //增加到访问结点结合
                  }
            }
        }
        return -1;
    }

    bool connection(vector<int> &a,vector<int>&b)    //判断两个结点是否互通
    {
     
        int i=0,j=0;
        while(i<a.size()&&j<b.size())       //由于数组已完成排序，采用双指针搜索，提高效率
        {
     
            if(a[i]==b[j])
                return true;
            else if(a[i]>b[j])
                j++;
            else 
                i++;
        }
        return false;
    }
};

4.总结

此题考察点：问题的抽象能力以及应变能力，要想到图的结点为公交车，而不是车站。
BFS为基本算法，难度不大。