-
Notifications
You must be signed in to change notification settings - Fork 2
/
DesignUndergroundSystem.java
148 lines (130 loc) · 5.66 KB
/
DesignUndergroundSystem.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
package Leetcode;
import java.util.HashMap;
import java.util.Map;
/**
* @author kalpak
*
* Implement the UndergroundSystem class:
*
* void checkIn(int id, string stationName, int t)
* - A customer with a card id equal to id, gets in the station stationName at time t.
* - A customer can only be checked into one place at a time.
*
* void checkOut(int id, string stationName, int t)
* - A customer with a card id equal to id, gets out from the station stationName at time t.
*
* double getAverageTime(string startStation, string endStation)
* - Returns the average time to travel between the startStation and the endStation.
* - The average time is computed from all the previous traveling from startStation to endStation that happened directly.
* - Call to getAverageTime is always valid.
*
* You can assume all calls to checkIn and checkOut methods are consistent.
* If a customer gets in at time t1 at some station, they get out at time t2 with t2 > t1. All events happen in chronological order.
*
*
*
* Example 1:
* Input
* ["UndergroundSystem","checkIn","checkIn","checkIn","checkOut","checkOut","checkOut","getAverageTime","getAverageTime","checkIn","getAverageTime","checkOut","getAverageTime"]
* [[],[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"]]
*
* Output
* [null,null,null,null,null,null,null,14.00000,11.00000,null,11.00000,null,12.00000]
*
* Explanation
* UndergroundSystem undergroundSystem = new UndergroundSystem();
* undergroundSystem.checkIn(45, "Leyton", 3);
* undergroundSystem.checkIn(32, "Paradise", 8);
* undergroundSystem.checkIn(27, "Leyton", 10);
* undergroundSystem.checkOut(45, "Waterloo", 15);
* undergroundSystem.checkOut(27, "Waterloo", 20);
* undergroundSystem.checkOut(32, "Cambridge", 22);
* undergroundSystem.getAverageTime("Paradise", "Cambridge"); // return 14.00000. There was only one travel from "Paradise" (at time 8) to "Cambridge" (at time 22)
* undergroundSystem.getAverageTime("Leyton", "Waterloo"); // return 11.00000. There were two travels from "Leyton" to "Waterloo", a customer with id=45 from time=3 to time=15 and a customer with id=27 from time=10 to time=20. So the average time is ( (15-3) + (20-10) ) / 2 = 11.00000
* undergroundSystem.checkIn(10, "Leyton", 24);
* undergroundSystem.getAverageTime("Leyton", "Waterloo"); // return 11.00000
* undergroundSystem.checkOut(10, "Waterloo", 38);
* undergroundSystem.getAverageTime("Leyton", "Waterloo"); // return 12.00000
*
* Example 2:
*
* Input
* ["UndergroundSystem","checkIn","checkOut","getAverageTime","checkIn","checkOut","getAverageTime","checkIn","checkOut","getAverageTime"]
* [[],[10,"Leyton",3],[10,"Paradise",8],["Leyton","Paradise"],[5,"Leyton",10],[5,"Paradise",16],["Leyton","Paradise"],
* [2,"Leyton",21],[2,"Paradise",30],["Leyton","Paradise"]]
*
* Output
* [null,null,null,5.00000,null,null,5.50000,null,null,6.66667]
*
* Explanation
* UndergroundSystem undergroundSystem = new UndergroundSystem();
* undergroundSystem.checkIn(10, "Leyton", 3);
* undergroundSystem.checkOut(10, "Paradise", 8);
* undergroundSystem.getAverageTime("Leyton", "Paradise"); // return 5.00000
* undergroundSystem.checkIn(5, "Leyton", 10);
* undergroundSystem.checkOut(5, "Paradise", 16);
* undergroundSystem.getAverageTime("Leyton", "Paradise"); // return 5.50000
* undergroundSystem.checkIn(2, "Leyton", 21);
* undergroundSystem.checkOut(2, "Paradise", 30);
* undergroundSystem.getAverageTime("Leyton", "Paradise"); // return 6.66667
*
*
* Constraints:
*
* There will be at most 20000 operations.
* 1 <= id, t <= 10^6
* All strings consist of uppercase and lowercase English letters, and digits.
* 1 <= stationName.length <= 10
* Answers within 10-5 of the actual value will be accepted as correct.
*/
public class DesignUndergroundSystem {
private Map<Integer, Event> arrivals;
private Map<String, Average> averages;
private final String DELIMETER = ",";
public DesignUndergroundSystem() {
arrivals = new HashMap<>();
averages = new HashMap<>();
}
public void checkIn(int id, String stationName, int t) {
Event eventObj = new Event(id, stationName, t);
arrivals.put(id, eventObj);
}
public void checkOut(int id, String stationName, int t) {
Event arrivalEvent = arrivals.get(id);
arrivals.remove(id);
int travelTime = t - arrivalEvent.time;
String key = arrivalEvent.stationName + DELIMETER + stationName;
// Now check if key is present in average or not.
// if not create an object or get the respective object.
// update the object.
Average avg = averages.containsKey(key) ? averages.get(key) : new Average();
avg.updateTravelInfo(travelTime);
averages.put(key, avg);
}
public double getAverageTime(String startStation, String endStation) {
String key = startStation + DELIMETER + endStation;
return averages.get(key).getAverage();
}
class Event {
public int id;
public String stationName;
public int time;
public Event(int id, String stationName, int time) {
this.id = id;
this.stationName = stationName;
this.time = time;
}
}
class Average {
public double total = 0;
public int count = 0;
public void updateTravelInfo(int travelTime) {
total += travelTime;
count++;
}
public double getAverage() {
return total / count;
}
}
}