题目如下：
Zhejiang University has 6 campuses and a lot of gates. From each gate we can collect the in/out times and the plate numbers of the cars crossing the gate. Now with all the information available, you are supposed to tell, at any specific time point, the number of cars parking on campus, and at the end of the day find the cars that have parked for the longest time period.
Input Specification:
Each input file contains one test case. Each case starts with two positive integers N (<= 10000), the number of records, and K (<= 80000) the number of queries. Then N lines follow, each gives a record in the format
plate_number hh:mm:ss status
where plate_number is a string of 7 English capital letters or 1-digit numbers; hh:mm:ss represents the time point in a day by hour:minute:second, with the earliest time being 00:00:00 and the latest 23:59:59; and status is either in or out.
Note that all times will be within a single day. Each "in" record is paired with the chronologically next record for the same car provided it is an "out" record. Any "in" records that are not paired with an "out" record are ignored, as are "out" records not paired with an "in" record. It is guaranteed that at least one car is well paired in the input, and no car is both "in" and "out" at the same moment. Times are recorded using a 24-hour clock.
Then K lines of queries follow, each gives a time point in the format hh:mm:ss. Note: the queries are given in ascending order of the times.
Output Specification:
For each query, output in a line the total number of cars parking on campus. The last line of output is supposed to give the plate number of the car that has parked for the longest time period, and the corresponding time length. If such a car is not unique, then output all of their plate numbers in a line in alphabetical order, separated by a space.
Sample Input:16 7 JH007BD 18:00:01 in ZD00001 11:30:08 out DB8888A 13:00:00 out ZA3Q625 23:59:50 out ZA133CH 10:23:00 in ZD00001 04:09:59 in JH007BD 05:09:59 in ZA3Q625 11:42:01 out JH007BD 05:10:33 in ZA3Q625 06:30:50 in JH007BD 12:23:42 out ZA3Q625 23:55:00 in JH007BD 12:24:23 out ZA133CH 17:11:22 out JH007BD 18:07:01 out DB8888A 06:30:50 in 05:10:00 06:30:50 11:00:00 12:23:42 14:00:00 18:00:00 23:59:00Sample Output:
1 4 5 2 1 0 1 JH007BD ZD00001 07:20:09
题目要求统计车辆的出入记录，对特定时间进行查询，判断停车数量与一天之内停车时间最长的所有车辆。
因为一辆车可能多次出入，因此为了方便统计，我们应该先把所有记录按照时间的升序排列，然后逐条处理，为了方便时间的处理，我们全部化为秒。
为了方便根据车牌号找到车辆，使用map存储车的信息。
每辆车用一个结构体，存储如下：
struct Car{
string plate_num;
bool valid;
int inTime;
int outTime;
int total;
Car(){
valid = false;
inTime = outTime = -1;
total = 0;
}
bool operator < (const Car& other) const{
return total > other.total;
}
};
对每一条记录，先在map里找这辆车，找不到则创建，配对in和out通过inTime和outTime两个成员属性，他们默认为-1，当读到一条in时，直接把in赋给inTime；当读到一条out时，判断inTime≠-1是否成立，成立再判断outTime赋值后是否大于inTime，是则说明是一条有效记录，计入车的总停靠时长total。
注意到题目中说查询按照升序，因此我们可以根据每个车的有效记录建立一个vector，并且按照时间排序，对每个查询时间，碰到in则说明多了一辆车，碰到out则说明少了一辆车，因此我们设计查询结点存储记录，value当in时为1，out时为-1。
struct QueryNode{
int time;
int value;
QueryNode(int t, int v){
time = t;
value = v;
}
bool operator < (const QueryNode& other) const{
return time < other.time;
}
};很显然，在上面碰到有效记录时，同时把对应inTime、value=1和outTime、value=-1压入存储查询结点的结构体，方便后面查询。
经过上面的工作，查询就变得十分简单，只需要从前到后遍历查询结点vector，并且每次不必重新遍历而是由上次的位置继续向后，这样才能避免超时。
对于最长时间车辆的输出，因为我们记录了每辆车的总时长total，把所有合法的车辆用一个vector存储，按照total降序排序，并把那些从前到后total一样的第一组全部取出，压入一个vector<string>，按照字典序排序输出即可，而这个total通过运算得到时分秒即可得到总时长的格式化输出。
代码如下：
#include <iostream>
#include <stdio.h>
#include <vector>
#include <map>
#include <algorithm>
#include <string.h>
using namespace std;
struct Car{
string plate_num;
bool valid;
int inTime;
int outTime;
int total;
Car(){
valid = false;
inTime = outTime = -1;
total = 0;
}
bool operator < (const Car& other) const{
return total > other.total;
}
};
struct Record{
string plate_num;
int time;
char *state;
Record(string plate, int t, char *s){
plate_num = plate;
time = t;
state = s;
}
bool operator < (const Record& other) const {
return time < other.time;
}
};
struct QueryNode{
int time;
int value;
QueryNode(int t, int v){
time = t;
value = v;
}
bool operator < (const QueryNode& other) const{
return time < other.time;
}
};
int main()
{
map<string,Car> carMap;
vector<Record> records;
vector<QueryNode> queryNodes;
int N,K;
int h,m,s;
cin >> N >> K;
for(int i = 0; i < N; i++){
string plate_num;
char *state = new char[2];
cin >> plate_num;
scanf("%d:%d:%d%s",&h,&m,&s,state);
records.push_back(Record(plate_num,h * 3600 + m * 60 + s,state));
}
sort(records.begin(),records.end());
for(int i = 0; i < records.size(); i++){
Record &r = records[i];
if(r.state[0] == 'i'){ // in
if(carMap.find(r.plate_num) == carMap.end()){
Car c = Car();
c.plate_num = r.plate_num;
c.inTime = r.time;
carMap[r.plate_num] = c;
}else{
Car &c = carMap[r.plate_num];
c.inTime = r.time;
}
}else{ // out
if(carMap.find(r.plate_num) == carMap.end()){
Car c = Car();
c.plate_num = r.plate_num;
c.outTime = r.time;
carMap[r.plate_num] = c;
}else{
Car &c = carMap[r.plate_num];
c.outTime = r.time;
if(c.inTime != -1 && c.inTime < c.outTime){
QueryNode inQ = QueryNode(c.inTime,1);
QueryNode outQ = QueryNode(c.outTime,-1);
queryNodes.push_back(inQ);
queryNodes.push_back(outQ);
c.total += c.outTime - c.inTime;
c.inTime = c.outTime = -1;
c.valid = true;
}
}
}
}
vector<Car> validCars;
for(map<string,Car>::iterator it = carMap.begin(); it != carMap.end(); it++){
Car &c = it->second;
if(c.valid){
Car c = it->second;
validCars.push_back(c);
}
}
sort(queryNodes.begin(),queryNodes.end());
int cnt = 0;
int cur = 0;
for(int i = 0 ; i < K; i++){
scanf("%d:%d:%d",&h,&m,&s);
int t = h * 3600 + m * 60 + s;
while(cur < queryNodes.size()){
QueryNode q = queryNodes[cur];
if(q.time <= t){
cnt += q.value;
cur++;
}else{
break;
}
}
printf("%d
",cnt);
}
sort(validCars.begin(),validCars.end());
int maxTotal = validCars[0].total;
vector<string> carList;
carList.push_back(validCars[0].plate_num);
for(int i = 1; i < validCars.size(); i++){
Car c = validCars[i];
if(c.total == maxTotal){
carList.push_back(c.plate_num);
}else{
break;
}
}
sort(carList.begin(),carList.end());
for(int i = 0; i < carList.size(); i++){
printf("%s ",carList[i].c_str());
}
h = maxTotal / 3600;
m = (maxTotal - h * 3600) / 60;
s = maxTotal % 60;
printf("%02d:%02d:%02d
",h,m,s);
return 0;
}