1095. Cars on Campus (30)

看了几个别人写的，感觉这个还不错

http://blog.csdn.net/xyt8023y/article/details/48029443

写一次理解：

1.首先把这N条记录存储起来，按时间从小到大排序，时间统计转换为秒

2.遍历该N条记录，存放到map中，有in，有out，且inTime<outTime为一条完整的有效记录，把有效记录存起来；并同时计算该车的总停车时间（同一个车可能同时进出多次）

3.按时间从小到大的顺便排序2中存的有效记录，截止到查询时间，算出到此刻里面的车数

4.将2中的有效记录车存起来，从大到小排序他的总停车时间，有多个最大停车时间的车存起来，进行输出，最后输出最大的停车时间

CODE

#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()
{
	#ifndef ONLINE_JUDGE
	freopen("input.txt","r",stdin);
	#endif
	    
	int N,K;
    scanf("%d %d",&N,&K);
    
    vector<Record> records;
	int h,m,s;
    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());//把记录按时间顺序排序 
    
    map<string,Car> carMap;
    vector<QueryNode> queryNodes;
    for(int i = 0; i < records.size(); i++){
        Record &r = records[i];//&表示引用，给record[i]起了一个名字叫r，不是一个新的变量，不分配存储空间 
        if(r.state[0] == 'i'){ // in
            if(carMap.find(r.plate_num) == carMap.end()){//map中不存在该车 
                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;//原来的inTime被覆盖 
            }
        }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;
                }
            }
        }
    }
    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);
    }

	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(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);
    
   	#ifndef ONLINE_JUDGE
	fclose(stdin);
	#endif
    return 0;
}