pat 甲级 Cars on Campus (30)

Cars on Campus (30)

时间限制 1000 ms 内存限制 65536 KB 代码长度限制 100 KB 判断程序 Standard 

题目描述

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.

输入描述:

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.

输出描述:

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.

输入例子:

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:00

输出例子:

1
4
5
2
1
0
1
JH007BD ZD00001 07:20:09
题意：一天当中不同时间段都会有车进或出停车场，给定一个时间点，判断这个时间点上有多少车停留在停车场上。并且最后输出在停车场上逗留时间最长的车的号码以及逗留时间。
思路：要注意每辆车每天可能会多次进出停车场，并且每一个进场的记录必须与时间离它最近的一个出场纪录配对，匹配不到出场纪录则这个进场记录无效，匹配不到进场记录的出场纪录也无效。
直接模拟，不过发现有一个样例有时过，有时超时，有点卡时，后来看了别人的题解，发现可以用树状数组优化，以1秒为以1单位，所有时间转化成秒。这样若有一个记录，车辆进出场时间段为[l,r],
那么树状数组维护的[l,r]区间每个位置都从0变成1即可。查询一辆车某个时间点是否在场，只需判断这个时间点是否为1。最后找逗留时间最长的车辆，对树状数组取和即可知道一辆车逗留时长。有时间时可以再用树状数组做做
模拟代码：

#define _CRT_SECURE_NO_DEPRECATE
#include<iostream>
#include<cmath>
#include<algorithm>
#include<cstring>
#include<vector>
#include<string>
#include<iomanip>
#include<map>
#include<stack>
#include<set>
#include<queue>
using namespace std;
#define N_MAX 10000+5
#define INF 0x3f3f3f3f
typedef long long ll;
int n, k;
struct Time {
    int value;
    bool is_in=0;
    Time() {}
    Time(int value,bool is_in):value(value),is_in(is_in) {}
    bool operator < (const Time & b) const{
        return value < b.value;
    }
};

struct Car {
    string id;
    set<Time>time;
    vector<pair<int,int> >vec;//存储一对进出的信息
    int sum_time=0;
}car[N_MAX];
map<string, int>car_index;
int tran(int h,int min,int s) {
    return h * 3600 + min * 60 + s;
}
vector<int> recover(int x) {
    vector<int>vec; vec.resize(3);
    vec[0]=(x / 3600);
    x %= 3600;
    vec[1]=(x / 60);
    x %= 60;
    vec[2]=x;
    return vec;
}
int main() {
    while (scanf("%d%d",&n,&k)!=EOF) {
        int num = 1;
        for (int i = 0; i < n;i++) {
            int hour, min, sec, value; string id; char status[4],Id[15];
            scanf("%s",Id);
            id = Id;
            scanf("%d:%d:%d",&hour,&min,&sec);value = tran(hour, min, sec);
            scanf("%s",status);
            if (status[0] == 'i') {
                if (car_index[id] == 0) { car_index[id] = num++; car[car_index[id]].id = id; }//添加新车记录
                car[car_index[id]].time.insert(Time(value,1));
            }
            else {
                if (car_index[id] == 0) { car_index[id] = num++; car[car_index[id]].id = id; }//添加新车记录
                car[car_index[id]].time.insert(Time(value,0));
            }
        }

        for (int i = 1; i < num;i++) {//筛选正确信息
            bool flag = 0;//判断是否有需要匹配的时间点
            Time need_match;
            for (set<Time>::iterator it = car[i].time.begin(); it != car[i].time.end();it++) {
                Time time = *it;
                if (!flag&&time.is_in) { flag = 1; need_match = time; }
                else if (flag&&time.is_in) need_match = time;
                else if (flag&&time.is_in == 0) {
                    car[i].vec.push_back(make_pair(need_match.value, time.value));
                    car[i].sum_time += time.value - need_match.value;
                    flag = 0;
                }
            }
         }

        while (k--) {
            int hour, min, sec, time,cnt=0;
            scanf("%d:%d:%d", &hour, &min, &sec);
            time = tran(hour, min, sec);
            for (int i = 1; i < num;i++) {
                for (int j = 0; j < car[i].vec.size();j++) {
                    if (time >= car[i].vec[j].first&&time < car[i].vec[j].second) {
                        cnt++; break;
                    }
                }
            } 
            printf("%d
",cnt);
        }
        set<string>S;
        int max_time=0;
        for (int i = 1; i < num;i++) {
            if (car[i].sum_time > max_time) {
                max_time = car[i].sum_time;
                S.clear();
                S.insert(car[i].id);
            }
            else if (car[i].sum_time == max_time) {
                S.insert(car[i].id);
            }
        }
        for (set<string>::iterator it = S.begin(); it != S.end();it++) {
            printf("%s ",(*it).c_str());
        }
        vector<int>rec = recover(max_time);
        printf("%02d:%02d:%02d
",rec[0],rec[1],rec[2]);
    }
    return 0;
}