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
|
import random
from collections import Counter, defaultdict, deque
from datetime import datetime, timedelta
from functools import lru_cache, reduce
from heapq import heapify, heappop, heappush, nlargest, nsmallest
from itertools import combinations, compress, permutations, starmap, tee
from math import ceil, comb, fabs, floor, gcd, hypot, log, perm, sqrt
from string import ascii_lowercase, ascii_uppercase
from sys import exit, setrecursionlimit, stdin
from typing import Any, Callable, Dict, List, Optional, Tuple, TypeVar, Union
TYPE = TypeVar('TYPE')
N = int(2e5 + 10)
M = int(20)
INF = int(1e12)
OFFSET = int(100)
MOD = int(1e9 + 7)
setrecursionlimit(int(2e9))
class Arr:
array = staticmethod(lambda x=0, size=N: [x() if callable(x) else x for _ in range(size)])
array2d = staticmethod(lambda x=0, rows=N, cols=M: [Arr.array(x, cols) for _ in range(rows)])
graph = staticmethod(lambda size=N: [[] for _ in range(size)])
class Math:
max = staticmethod(lambda a, b: a if a > b else b)
min = staticmethod(lambda a, b: a if a < b else b)
class IO:
input = staticmethod(lambda: stdin.readline().strip())
read = staticmethod(lambda: map(int, IO.input().split()))
read_list = staticmethod(lambda: list(IO.read()))
read_mixed = staticmethod(lambda *types: [t(v) for t, v in zip(types, IO.input().split())])
class Std:
pass
def convert_time(time: str) -> int:
h, m, s = map(int, time.split(":"))
return h * 3600 + m * 60 + s
def convert_index(x: int) -> str:
return f"{x // 3600:02}:{x % 3600 // 60:02}:{x % 60:02}"
n, k = IO.read()
diff_ = Arr.array(0, convert_time("24:00:01"))
map_ = defaultdict(lambda: {
"in": [],
"out": []
})
for _ in range(n):
string, time, status = IO.read_mixed(str, str, str)
map_[string][status].append(time)
max_ = Counter()
max_val = 0
for user, dict_ in map_.items():
in_ = dict_["in"]
out_ = dict_["out"]
res = []
res.extend([(convert_time(item), "in") for item in in_])
res.extend([(convert_time(item), "out") for item in out_])
res.sort(key=lambda x: x[0])
pre_in, pre_out = -1, -1
for index, st in res:
if st == "in":
pre_in = index
if st == "out":
pre_out = index
if pre_in != -1 and pre_out != -1 and st == "out" and index > pre_in:
diff_[pre_in] += 1
diff_[index] -= 1
val = index - pre_in
max_[user] += val
max_val = Math.max(max_val, max_[user])
pre_in, pre_out = -1, -1
for i in range(1, len(diff_)):
diff_[i] += diff_[i - 1]
for _ in range(k):
time = IO.input()
print(diff_[convert_time(time)])
users_ = [user for user in max_.keys() if max_[user] == max_val]
users_.sort()
print(" ".join(users_), convert_index(max_val))
|