哈希表题目：设计地铁系统

题目

标题和出处

标题：设计地铁系统

出处：1396. 设计地铁系统

难度

6 级

题目描述

要求

一个地铁系统正在收集乘客在不同站之间的花费时间。他们在使用这些数据计算从一个地铁站到另一个地铁站的平均花费时间。

实现 $\text{UndergroundSystem}$ 类：

• $\text{void checkIn(int id, string stationName, int t)}$
  • 卡号为 $\text{id}$ 的乘客在 $\text{t}$ 时刻进入地铁站 $\text{stationName}$。
  • 一个乘客在同一时间只能进入一个地点。
• $\text{void checkOut(int id, string stationName, int t)}$
  • 卡号为 $\text{id}$ 的乘客在 $\text{t}$ 时刻离开地铁站 $\text{stationName}$。
• $\text{double getAverageTime(string startStation, string endStation)}$
  • 返回从地铁站 $\text{startStation}$ 到地铁站 $\text{endStation}$ 的平均花费时间。
  • 平均时间计算的行程包括当前为止所有从 $\text{startStation}$ 直接到达 $\text{endStation}$ 的行程，即进入地铁站 $\text{startStation}$ 之后离开地铁站 $\text{endStation}$。
  • 从地铁站 $\text{startStation}$ 到地铁站 $\text{endStation}$ 的花费时间可能不同于从地铁站 $\text{endStation}$ 到地铁站 $\text{startStation}$ 的花费时间。
  • 调用 $\text{getAverageTime}$ 时，至少已经有一个乘客从地铁站 $\text{startStation}$ 乘坐到地铁站 $\text{endStation}$。

你可以假设所有对 $\text{checkIn}$ 和 $\text{checkOut}$ 的调用都是符合逻辑的。如果一个乘客在 ${\text{t}}_{\text{1}}$ 时刻进入某个地铁站并在 ${\text{t}}_{\text{2}}$ 时刻离开某个地铁站，那么 ${\text{t}}_{\text{1}}<{\text{t}}_{\text{2}}$。所有的事件都按时间顺序给出。

示例

示例 1：

输入：
$\text{["UndergroundSystem","checkIn","checkIn","checkIn","checkOut","checkOut","checkOut","getAverageTime","getAverageTime","checkIn","getAverageTime","checkOut","getAverageTime"]}$
$\text{[[],[45,"Leyton",3],[32,"Paradise",8],[27,"Leyton",10],[45,"Waterloo",15],[27,"Waterloo",20],[32,"Cambridge",22],["Paradise","Cambridge"],["Leyton","Waterloo"],[10,"Leyton",24],["Leyton","Waterloo"],[10,"Waterloo",38],["Leyton","Waterloo"]]}$
输出：
$\text{[null,null,null,null,null,null,null,14.00000,11.00000,null,11.00000,null,12.00000]}$
解释：
$\text{UndergroundSystem undergroundSystem = new UndergroundSystem();}$
$\text{undergroundSystem.checkIn(45, "Leyton", 3);}$
$\text{undergroundSystem.checkIn(32, "Paradise", 8);}$
$\text{undergroundSystem.checkIn(27, "Leyton", 10);}$
$\text{undergroundSystem.checkOut(45, "Waterloo", 15);}$ // 乘客 $\text{45}$ 从 $\text{"Leyton"}$ 到 $\text{"Waterloo"}$ 的时间是 $\text{15 - 3 = 12}$
$\text{undergroundSystem.checkOut(27, "Waterloo", 20);}$ // 乘客 $\text{27}$ 从 $\text{"Leyton"}$ 到 $\text{"Waterloo"}$ 的时间是 $\text{20 - 10 = 10}$
$\text{undergroundSystem.checkOut(32, "Cambridge", 22);}$ // 乘客 $\text{32}$ 从 $\text{"Paradise"}$ 到 $\text{"Cambridge"}$ 的时间是 $\text{22 - 8 = 14}$
$\text{undergroundSystem.getAverageTime("Paradise", "Cambridge");}$ // 返回 $\text{14.00000}$。从 $\text{"Paradise"}$ 到 $\text{"Cambridge"}$ 的行程有 $\text{1}$ 个，$\text{(14) / 1 = 14}$
$\text{undergroundSystem.getAverageTime("Leyton", "Waterloo");}$ // 返回 $\text{11.00000}$。从 $\text{"Leyton"}$ 到 $\text{"Waterloo"}$ 的行程有 $\text{2}$ 个，$\text{(10 + 12) / 2 = 11}$
$\text{undergroundSystem.checkIn(10, "Leyton", 24);}$
$\text{undergroundSystem.getAverageTime("Leyton", "Waterloo");}$ // 返回 $\text{11.00000}$
$\text{undergroundSystem.checkOut(10, "Waterloo", 38);}$ // 乘客 $\text{10}$ 从 $\text{"Leyton"}$ 到 $\text{"Waterloo"}$ 的时间是 $\text{38 - 24 = 14}$
$\text{undergroundSystem.getAverageTime("Leyton", "Waterloo");}$ // 返回 $\text{12.00000}$。从 $\text{"Leyton"}$ 到 $\text{"Waterloo"}$ 的行程有 $\text{3}$ 个，$\text{(10 + 12 + 14) / 3 = 12}$

示例 2：

输入：
$\text{["UndergroundSystem","checkIn","checkOut","getAverageTime","checkIn","checkOut","getAverageTime","checkIn","checkOut","getAverageTime"]}$
$\text{[[],[10,"Leyton",3],[10,"Paradise",8],["Leyton","Paradise"],[5,"Leyton",10],[5,"Paradise",16],["Leyton","Paradise"],[2,"Leyton",21],[2,"Paradise",30],["Leyton","Paradise"]]}$
输出：
$\text{[null,null,null,5.00000,null,null,5.50000,null,null,6.66667]}$
解释：
$\text{UndergroundSystem undergroundSystem = new UndergroundSystem();}$
$\text{undergroundSystem.checkIn(10, "Leyton", 3);}$
$\text{undergroundSystem.checkOut(10, "Paradise", 8);}$ // 乘客 $\text{10}$ 从 $\text{"Leyton"}$ 到 $\text{"Paradise"}$ 的时间是 $\text{8 - 3 = 5}$
$\text{undergroundSystem.getAverageTime("Leyton", "Paradise");}$ // 返回 $\text{5.00000}$。$\text{(5) / 1 = 5}$
$\text{undergroundSystem.checkIn(5, "Leyton", 10);}$
$\text{undergroundSystem.checkOut(5, "Paradise", 16);}$ // 乘客 $\text{5}$ 从 $\text{"Leyton"}$ 到 $\text{"Paradise"}$ 的时间是 $\text{16 - 10 = 6}$
$\text{undergroundSystem.getAverageTime("Leyton", "Paradise");}$ // 返回 $\text{5.50000}$。$\text{(5 + 6) / 2 = 5.5}$
$\text{undergroundSystem.checkIn(2, "Leyton", 21);}$
$\text{undergroundSystem.checkOut(2, "Paradise", 30);}$ // 乘客 $\text{2}$ 从 $\text{"Leyton"}$ 到 $\text{"Paradise"}$ 的时间是 $\text{30 - 21 = 9}$
$\text{undergroundSystem.getAverageTime("Leyton", "Paradise");}$ // 返回 $\text{6.66667}$。$\text{(5 + 6 + 9) / 3 = 6.66667}$

数据范围

• $\text{1}\le \text{id, t}\le {\text{10}}^{\text{6}}$
• $\text{1}\le \text{stationName.length, startStation.length, endStation.length}\le \text{10}$
• 所有的字符串包含大写字母、小写字母和数字
• 总共最多调用 $\text{2}\times {\text{10}}^{\text{4}}$ 次 $\text{checkIn}$、$\text{checkOut}$ 和 $\text{getAverageTime}$
• 与标准答案误差在 ${\text{10}}^{\text{-5}}$ 以内的结果都视为正确结果

解法

思路和算法

这道题要求收集乘客在不同站之间的花费时间，并根据这些数据计算从一个地铁站到另一个地铁站的平均花费时间。

一个乘客在 $t_1$ 时刻进入地铁站 $s_1$，然后在 $t_2$ 时刻离开地铁站 $s_2$，则该乘客从地铁站 $s_1$ 到地铁站 $s_2$ 的花费时间是 $t_2-t_1$。为了记录乘客在不同站之间的花费时间，需要使用哈希表记录每个乘客的卡号以及该乘客进入的地铁站和进站时刻，当乘客离开另一个地铁站时，可以根据乘客的卡号得到该乘客进入的地铁站和进站时刻，结合乘客离开的地铁站和出站时刻即可得到由起点和终点组成的旅程信息，以及花费时间。

为了计算两个特定地铁站之间的平均花费时间，需要使用哈希表记录每个旅程以及该旅程的总时间与次数。当乘客离开地铁站时，即可得到该乘客的旅程信息和花费时间，将该旅程的总时间加上该乘客的花费时间，将该旅程的次数加 $1$，总时间除以次数即为该旅程的平均花费时间。

基于上述分析，需要维护两个哈希表，分别记录进站信息和旅程时间。

构造方法中，将两个哈希表初始化。

对于 $\text{checkIn}$ 操作，根据站名和时刻构造进站信息，将卡号和进站信息存入进站信息哈希表。

对于 $\text{checkOut}$ 操作，根据卡号 $\text{id}$ 从进站信息哈希表中得到进站信息，从进站信息得到进入的地铁站 $\text{startStation}$ 和进站时刻 $\text{startTime}$，结合离开的地铁站 $\text{stationName}$ 和出站时刻 $t$，得到旅程为进入的地铁站和离开的地铁站拼接之后的字符串，花费时间为 $t-\text{startTime}$，将旅程和花费时间存入旅程时间哈希表。

对于 $\text{getAverageTime}$ 操作，根据进入的地铁站 $\text{startStation}$ 和离开的地铁站 $\text{endStation}$ 得到旅程，从旅程时间哈希表中得到该旅程的总时间与次数，总时间除以次数即为该旅程的平均花费时间。

由于所有的事件都按时间顺序出现，同一个乘客一定是先进站后出站，当一个乘客出站之后，不可能在进站之前第二次出站，因此当乘客出站时，不需要将该乘客的进站信息从进站信息哈希表中删除。

代码

class UndergroundSystem {
    private class CheckInInfo {
        private String station;
        private int time;

        public CheckInInfo(String station, int time) {
            this.station = station;
            this.time = time;
        }

        public String getStation() {
            return station;
        }

        public int getTime() {
            return time;
        }
    }

    private Map<Integer, CheckInInfo> checkInMap;
    private Map<String, int[]> tripTimeMap;

    public UndergroundSystem() {
        checkInMap = new HashMap<Integer, CheckInInfo>();
        tripTimeMap = new HashMap<String, int[]>();
    }

    public void checkIn(int id, String stationName, int t) {
        CheckInInfo info = new CheckInInfo(stationName, t);
        checkInMap.put(id, info);
    }

    public void checkOut(int id, String stationName, int t) {
        CheckInInfo info = checkInMap.get(id);
        String startStation = info.getStation();
        int startTime = info.getTime();
        String key = startStation + "," + stationName;
        tripTimeMap.putIfAbsent(key, new int[2]);
        int[] time = tripTimeMap.get(key);
        time[0] += t - startTime;
        time[1]++;
    }

    public double getAverageTime(String startStation, String endStation) {
        String key = startStation + "," + endStation;
        int[] time = tripTimeMap.get(key);
        return 1.0 * time[0] / time[1];
    }
}

复杂度分析

• 时间复杂度：构造方法和各项操作的时间复杂度都是 $O(1)$。构造方法初始化两个哈希表，各项操作均为操作哈希表和计算花费时间，因此时间复杂度是 $O(1)$。这里将字符串操作的时间视为 $O(1)$。

• 空间复杂度：$O(n)$，其中 $n$ 是所有方法的总调用次数。需要使用两个哈希表分别记录进站信息和旅程时间，每个哈希表中的元素个数都是 $O(n)$。