1396. Design Underground System

public class UndergroundSystem {
    private Dictionary<string, (double totalTime, double trips)> journeyData = new Dictionary<string, (double, double)>();
    private Dictionary<int, (string stationName, int time)> checkInData = new Dictionary<int, (string, int)>();
    public void CheckIn(int id, string stationName, int t) {
        checkInData[id] = (stationName, t);
    }
    public void CheckOut(int id, string stationName, int t) {
        var (startStation, startTime) = checkInData[id];
        checkInData.Remove(id);
        var routeKey = $"{startStation}->{stationName}";
        var tripTime = t - startTime;
        if (!journeyData.ContainsKey(routeKey)) {
            journeyData[routeKey] = (0, 0);
        }
        var (totalTime, trips) = journeyData[routeKey];
        journeyData[routeKey] = (totalTime + tripTime, trips + 1);
    }
    public double GetAverageTime(string startStation, string endStation) {
        var (totalTime, trips) = journeyData[$"{startStation}->{endStation}"];
        return totalTime / trips;
    }
}

#include <bits/stdc++.h>
using namespace std;

// Auto-generated C++ draft from the C# solution. Review containers, LINQ and helper types before submit.
public class UndergroundSystem {
    private unordered_map<string, (double totalTime, double trips)> journeyData = new unordered_map<string, (double, double)>();
    private unordered_map<int, (string stationName, int time)> checkInData = new unordered_map<int, (string, int)>();
    public void CheckIn(int id, string stationName, int t) {
        checkInData[id] = (stationName, t);
    }
    public void CheckOut(int id, string stationName, int t) {
        var (startStation, startTime) = checkInData[id];
        checkInData.Remove(id);
        var routeKey = $"{startStation}->{stationName}";
        var tripTime = t - startTime;
        if (!journeyData.count(routeKey)) {
            journeyData[routeKey] = (0, 0);
        }
        var (totalTime, trips) = journeyData[routeKey];
        journeyData[routeKey] = (totalTime + tripTime, trips + 1);
    }
    public double GetAverageTime(string startStation, string endStation) {
        var (totalTime, trips) = journeyData[$"{startStation}->{endStation}"];
        return totalTime / trips;
    }
}

class UndergroundSystem {
    private Map<String, double[]> journeyData = new HashMap<>();
    private Map<Integer, Pair<String, Integer>> checkInData = new HashMap<>();

    public void checkIn(int id, String stationName, int t) {
        checkInData.put(id, new Pair<>(stationName, t));
    }

    public void checkOut(int id, String stationName, int t) {
        Pair<String, Integer> checkIn = checkInData.remove(id);
        String routeKey = checkIn.getKey() + "->" + stationName;
        double tripTime = t - checkIn.getValue();
        journeyData.computeIfAbsent(routeKey, k -> new double[2]);
        journeyData.get(routeKey)[0] += tripTime;
        journeyData.get(routeKey)[1] += 1;
    }

    public double getAverageTime(String startStation, String endStation) {
        double[] stats = journeyData.get(startStation + "->" + endStation);
        return stats[0] / stats[1];
    }
}

class UndergroundSystem {
    constructor() {
        this.journeyData = new Map();
        this.checkInData = new Map();
    }

    checkIn(id, stationName, t) {
        this.checkInData.set(id, [stationName, t]);
    }

    checkOut(id, stationName, t) {
        const [startStation, startTime] = this.checkInData.get(id);
        this.checkInData.delete(id);
        const routeKey = `${startStation}->${stationName}`;
        const tripTime = t - startTime;
        if (!this.journeyData.has(routeKey)) {
            this.journeyData.set(routeKey, [0, 0]);
        }
        const [totalTime, trips] = this.journeyData.get(routeKey);
        this.journeyData.set(routeKey, [totalTime + tripTime, trips + 1]);
    }

    getAverageTime(startStation, endStation) {
        const [totalTime, trips] = this.journeyData.get(`${startStation}->${endStation}`);
        return totalTime / trips;
    }
}

type UndergroundSystem struct {
    journeyData map[string][2]float64
    checkInData map[int][2]interface{}
}

func Constructor() UndergroundSystem {
    return UndergroundSystem{
        journeyData: make(map[string][2]float64),
        checkInData: make(map[int][2]interface{}),
    }
}

func (this *UndergroundSystem) CheckIn(id int, stationName string, t int) {
    this.checkInData[id] = [2]interface{}{stationName, t}
}

func (this *UndergroundSystem) CheckOut(id int, stationName string, t int) {
    checkIn := this.checkInData[id]
    startStation := checkIn[0].(string)
    startTime := checkIn[1].(int)
    delete(this.checkInData, id)
    routeKey := startStation + "->" + stationName
    tripTime := float64(t - startTime)
    if _, exists := this.journeyData[routeKey]; !exists {
        this.journeyData[routeKey] = [2]float64{0, 0}
    }
    this.journeyData[routeKey][0] += tripTime
    this.journeyData[routeKey][1] += 1
}

func (this *UndergroundSystem) GetAverageTime(startStation string, endStation string) float64 {
    stats := this.journeyData[startStation+"->"+endStation]
    return stats[0] / stats[1]
}

Explanation

Algorithm

При регистрации на входе сохраняем информацию о начале пути (станция и время) в словаре checkInData.

При регистрации на выходе извлекаем информацию о начале пути из checkInData, вычисляем время поездки и обновляем статистику для маршрута в journeyData.

Для получения среднего времени поездки по заданному маршруту извлекаем статистику из journeyData и вычисляем среднее значение.

😎