1095. Cars on Campus (30)

标签：算法   pat   map   vector   事件模拟   

题目如下：

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

题目要求统计车辆的出入记录，对特定时间进行查询，判断停车数量与一天之内停车时间最长的所有车辆。

因为一辆车可能多次出入，因此为了方便统计，我们应该先把所有记录按照时间的升序排列，然后逐条处理，为了方便时间的处理，我们全部化为秒。

为了方便根据车牌号找到车辆，使用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;
    }
};

经过上面的工作，查询就变得十分简单，只需要从前到后遍历查询结点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\n",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\n",h,m,s);
    return 0;
}

1095. Cars on Campus (30)

标签：算法   pat   map   vector   事件模拟   

原文地址：http://blog.csdn.net/xyt8023y/article/details/48029443