POJ1025 Department

题目来源：http://poj.org/problem?id=1025

题目大意：

　　有一些特工，在一天里要访问一座大楼。这座大楼里有10层，每层10个房间（按xxyy编号每个房间，xx为楼层，yy为房间号）和1个电梯。每个特工要按顺序访问一些特定的房间，并在各个房间里待一段时间。每个特工在一天的某个时间点到达大楼的1层，然后需要30s的时间进行登记之类的活动。到达30s后可以到达一楼的电梯或到达他想要去的位于1楼的房间门口。大楼的电梯每5s一班，每上升一层或下降一层需要30s。出于安全考虑，每个房间和每层的电梯都同时只运行一个人在内。当有多人在电梯或房间门口需要进入时需要排队。每个特工都有一个唯一的编号（A->Z），编号越小，优先级越高，排队时优先。特工访问完一个房间去往下一个房间的过程中可能需要以下动作：从楼层的一个房间去往该层的另一个房间；从楼层的一个房间去往电梯->（等待电梯）->乘电梯->电梯去往另一层的某房间。当访问完所有需要访问的房间后，若特工在1层，则花30s办理手续，离开。若不在1层，则先下电梯至1层再办手续离开。一个特工一天只访问大楼一次，一天内所有活动都会完成。

各种动作需要的时间总结如下：

Entry：登记->到达1楼电梯或1楼某房间  30s

Exit：从最后一个房间或电梯出来至离开  30s

同一层，出电梯到达某房间（或进等候队列）或出房间到达电梯或出房间到到达另一房间  10s

从一层到另一层成电梯每上一层或下一层需要时间  30s

写一个程序来安排所有特工的活动。

输入：含有n>=0个不同的特工。首先输入该特工的编号，然后是进入大楼的时间。接下来的每行，前四个字符表示要访问的房间号码，后一个整数为该特工要在这个房间停留的时间。以0表示该特工的访问计划输入完毕。以"."表示所有输入结束。

输出：输出每个特工的编号加活动详细安排。

---

Sample Input

A 10:00:00
0101 100
0110 50
0202 90
0205 50
0
B 10:01:00
0105 100
0201 5
0205 200
0
.

Sample Output

A
10:00:00 10:00:30 Entry
10:00:30 10:02:10 Stay in room 0101
10:02:10 10:02:20 Transfer from room 0101 to room 0110
10:02:20 10:03:10 Stay in room 0110
10:03:10 10:03:20 Transfer from room 0110 to elevator
10:03:20 10:03:50 Stay in elevator
10:03:50 10:04:00 Transfer from elevator to room 0202
10:04:00 10:05:30 Stay in room 0202
10:05:30 10:05:40 Transfer from room 0202 to room 0205
10:05:40 10:07:40 Waiting in front of room 0205
10:07:40 10:08:30 Stay in room 0205
10:08:30 10:08:40 Transfer from room 0205 to elevator
10:08:40 10:09:10 Stay in elevator
10:09:10 10:09:40 Exit

B
10:01:00 10:01:30 Entry
10:01:30 10:03:10 Stay in room 0105
10:03:10 10:03:20 Transfer from room 0105 to elevator
10:03:20 10:03:25 Waiting in elevator queue
10:03:25 10:03:55 Stay in elevator
10:03:55 10:04:05 Transfer from elevator to room 0201
10:04:05 10:04:10 Stay in room 0201
10:04:10 10:04:20 Transfer from room 0201 to room 0205
10:04:20 10:07:40 Stay in room 0205
10:07:40 10:07:50 Transfer from room 0205 to elevator
10:07:50 10:08:20 Stay in elevator
10:08:20 10:08:50 Exit

---

本题是一道很复杂模拟题，虽然不必很复杂的算法设计，但是代码量很大，需要精心的设计，也是参考了别人的实现。

定义一个枚举类型表示每个特工当前所处的状态。

enum Event {
　　et_entry, et_wait_elevator, et_wait_room, et_room2room, et_elevator2room,
　　et_room2elevator, et_in_room, et_in_elevator, et_exit
};

把电梯看做一个特殊的房间，给予编号XX00。

为每一个房间准备一个等候队列，保存某时刻该房间的等候的特工。

每秒钟遍历每个特工和每个房间，更新特工、房间、电梯的状态。（每次到达电梯口或房间门口就将特工插入对应的等待队列，即使不需要等待，因为只要在输出时过滤掉等待0秒的过程即可。当房间或电梯可以让人进入时选择队列中优先级最高的让其进入。）具体见代码和注释。

//////////////////////////////////////////////////////////////////////////
//        POJ1025 Department
//        Memory: 312K        Time: 94MS
//        Language: C++        Result: Accepted
//////////////////////////////////////////////////////////////////////////

#include <iostream>
#include <string>
#include <cmath>
#include<iomanip>

using namespace std;

enum Event {
    et_entry, et_wait_elevator, et_wait_room, et_room2room, et_elevator2room,    
    et_room2elevator, et_in_room, et_in_elevator, et_exit
};
const size_t event_time[] = {30, 5, 0, 10, 10, 10, 0, 30, 30};

class Room {
public:
    bool o;
    int free_time;
    bool waiting_queue[26];
    int waiting_cnt;

    bool waiting_q_empty() {
        return waiting_cnt == 0 ? true :false;
    }
    void push(int agent_id) {
        waiting_queue[agent_id] = true;
        ++waiting_cnt;
    }
    int pop() {
        for (int i = 0; i < 26; ++i) {
            if (waiting_queue[i] == true) {
                waiting_queue[i] = false;
                --waiting_cnt;
                return i;
            }
        }
    }
};
Room room[11][11];
int current_time;
class Plan {
public:
    pair<int, int> p;
    Plan * next;
};
class Schedule {
public:
    Event e;
    int start_time;
    int end_time;
    int from;
    int to;
    Schedule * next;

    Schedule () {
        from = 0;
        to = 0;
        next = NULL;
    }
};
class Agent {
public:
    bool e;                //是否存在该Agent
    int id;
    int entry_time;
    int exit_time;
    Plan * plan;
    Schedule * schedule;

    void push_plan(pair<int, int> p) {
        Plan * pl = new Plan;
        Plan * pt;
        pl->p = p;
        pl->next = NULL;
        if (plan == NULL) {
            plan = pl;
            return;
        }
        for (pt = plan; pt->next != NULL; pt = pt->next) ;
        pt->next = pl;
    }

    pair<int, int> popr_plan() {
        return plan->p;
    }

    pair<int, int> pop_plan() {
        pair<int, int> pp = plan->p;
        plan = plan->next;
        return pp;
    }

    void push_schedule(Schedule * s) {
        Schedule * ps;
        if (schedule == NULL) {
            schedule = s;
            s->next = NULL;
            return;
        }
        for (ps = schedule; ps->next != NULL; ps = ps->next) ;
        ps->next = s;
        s->next = NULL;
    }
    Schedule * popr_schedule() {
        Schedule * ps;
        for (ps = schedule; ps->next != NULL; ps = ps->next) ;
        return ps;
    }
};
Agent agent[26];

void enqueue(int agent_id, int room_id) {
    Schedule * s = new Schedule;
    int floor = room_id / 100;
    int id = room_id % 100;
    room[floor][id].push(agent_id);
    if (id == 0) {
        s->e = et_wait_elevator;
    } else {
        s->e = et_wait_room;
    }
    s->start_time = current_time;
    s->end_time = room[floor][id].free_time > current_time ? room[floor][id].free_time : current_time;
    s->from = room_id;
    if (agent[agent_id].plan == NULL) {
        s->to = -1;
    } else {
        s->to = agent[agent_id].popr_plan().first;
    }
    agent[agent_id].push_schedule(s);
}
void process(int agent_id) {
    Schedule * s = agent[agent_id].popr_schedule();
    int from = s->from;
    int to = s->to;
    int floor = to / 100;
    int id = to % 100;
    switch (s->e) {
            case et_entry:
                //第一个房间在1楼，则已到达该房间
                if (floor == 1) {
                    //插入房间等待队列
                    enqueue(agent_id, to);
                } else {
                    //第一个房间在楼上，则已到达电梯，插入该电梯等候队列
                    enqueue(agent_id, 100);
                }
                break;
            case et_wait_elevator:
                //留在电梯等候队列
                break;
            case et_wait_room:
                //留在房间等候队列
                break;
            case et_room2room:
                //到达房间，插入房间等候队列
                enqueue(agent_id, to);
                break;
            case et_elevator2room:
                //到达房间，插入房间等候队列
                enqueue(agent_id, to);
                break;
            case et_room2elevator:
                //到达电梯，插入电梯等候队列
                enqueue(agent_id, from / 100 * 100);
                break;
            case et_in_room:
                //出房间，去电梯或去下一房间或exit
                room[from / 100][from % 100].o = false;
                if (to == -1) {
                    //即将exit
                    if (from / 100 == 1) {
                        Schedule * s = new Schedule;
                        s->e = et_exit;
                        s->start_time = current_time;
                        s->end_time = current_time + event_time[et_exit];
                        s->from = -1;
                        s->to = -1;
                        agent[agent_id].push_schedule(s);
                    } else {
                        //即将下电梯然后exit
                        Schedule * s = new Schedule;
                        s->e = et_room2elevator;
                        s->start_time = current_time;
                        s->end_time = current_time + event_time[et_room2elevator];
                        s->from = from; 
                        s->to = -1;
                        agent[agent_id].push_schedule(s);
                    }
                } else if (floor == from / 100) {
                    //下一房间在同一楼，room2room
                    Schedule * s = new Schedule;
                    s->e = et_room2room;
                    s->start_time = current_time;
                    s->end_time = current_time + event_time[et_room2room];
                    s->from = from;
                    s->to = to;
                    agent[agent_id].push_schedule(s);
                } else {
                    //下一房间在不同楼，room2elevator
                    Schedule * s = new Schedule;
                    s->e = et_room2elevator;
                    s->start_time = current_time;
                    s->end_time = current_time + event_time[et_room2elevator];
                    s->from = from;
                    s->to = to;
                    agent[agent_id].push_schedule(s);
                }
                break;
            case et_in_elevator:
                //出电梯，去下一房间或exit
                if (to == -1) {
                    //exit
                    Schedule * s = new Schedule;
                    s->e = et_exit;
                    s->start_time = current_time;
                    s->end_time = current_time + event_time[et_exit];
                    agent[agent_id].push_schedule(s);
                } else {
                    //去房间
                    Schedule * s = new Schedule;
                    s->e = et_elevator2room;
                    s->start_time = current_time;
                    s->end_time = current_time + event_time[et_room2room];
                    s->from = from;
                    s->to = to;
                    agent[agent_id].push_schedule(s);
                }
                break;
            case et_exit: 
                //该agent所有plan和schedule已完成
                agent[agent_id].exit_time = s->end_time;
                break;
    }
}

int str2int(string time) {
    return ((time[0] - '0') * 10 + (time[1] - '0')) * 3600 + 
        ((time[3] - '0') * 10 + (time[4] - '0')) * 60 + 
        (time[6] - '0') * 10 + (time[7] - '0');
}

string int2str(int time) {
    string str;
    str += time / 3600 / 10 + '0';
    str += time / 3600 % 10 + '0';
    str += ":";
    time = time - time / 3600 * 3600;
    str += time / 60 / 10 + '0';
    str += time / 60 % 10 + '0';
    str += ":";
    time = time - time / 60 * 60;
    str += time / 10 + '0';
    str += time % 10 + '0';
    return str;
}
void input() {
    while (true) {
        char prio;
        cin >> prio;
        if (prio == '.') {
            break;
        }
        int agent_id = prio - 'A';
        agent[agent_id].e = true;
        string entry;
        cin >> entry;
        int entry_time = str2int(entry);
        agent[agent_id].entry_time = entry_time;
        //读入计划
        while (true) {
            int room_id;
            cin >> room_id;
            if (room_id == 0) {
                break;
            }
            int time;
            cin >> time;
            agent[agent_id].push_plan(make_pair(room_id, time));
        }
        //将entry event写入schedule
        Schedule * schedule = new Schedule;
        schedule->e = et_entry;
        schedule->start_time = entry_time;
        schedule->end_time = entry_time + event_time[et_entry];
        schedule->from = 0;
        schedule->to = agent[agent_id].popr_plan().first;
        schedule->next = NULL;
        agent[agent_id].push_schedule(schedule);
    }
}
void initialize() {
    for (int i = 0; i < 26; ++i) {
        agent[i].e = false;
        agent[i].id = i;
        agent[i].entry_time = -1;
        agent[i].exit_time = 86401;
        agent[i].plan = NULL;
        agent[i].schedule = NULL;
    }
    for (int i = 0; i < 11; ++i) {
        for (int j = 0; j < 11; ++j) {
            room[i][j].waiting_cnt = 0;
            for (int k = 0; k < 26; ++k) {
                room[i][j].o = false;
                room[i][j].free_time = 0;
                room[i][j].waiting_queue[k] = false;
            }
        }
    }
} 

void print_entry(int start, int end) {
    cout << int2str(start) << " " << int2str(end) << " Entry" << endl;
}
void print_exit(int start, int end) {
    cout << int2str(start) << " " << int2str(end) << " Exit" << endl;
}
void print_in_room(int start, int end, int room) {
    cout << int2str(start) << " " << int2str(end) << " Stay in room " 
        <<  setfill('0') << setw(4) << room << endl;
}
void print_in_elevator(int start, int end) {
    cout << int2str(start) << " " << int2str(end) << " Stay in elevator" << endl; 
}
void print_room2room(int start, int end, int from, int to) {
    cout << int2str(start) << " " << int2str(end) << " Transfer from room " 
        << setfill('0') << setw(4) << from << " to room " << setfill('0') << setw(4) << to << endl;
}
void print_elevator2room(int start, int end, int room) {
    cout << int2str(start) << " "  << int2str(end) << " Transfer from elevator to room " 
        << setfill('0') << setw(4) << room << endl;
}
void print_room2elevator(int start, int end, int room) {
    cout << int2str(start) << " " << int2str(end) << " Transfer from room " 
        << setfill('0') << setw(4) << room << " to elevator" << endl;
}
void print_wait_room(int start, int end, int room) {
    if (start == end) return;
    cout << int2str(start) << " " << int2str(end) << " Waiting in front of room " 
        << setfill('0') << setw(4) << room << endl;
}
void print_wait_elevator(int start, int end) {
    if (start == end) return;
    cout << int2str(start) << " " << int2str(end) << " Waiting in elevator queue" << endl;
}
void output() {
    for (int i = 0; i < 26; ++i) {
        if (agent[i].e == false) {
            continue;
        }
        cout << char('A' + i) << endl;
        Schedule * schedule = agent[i].schedule;
        while (schedule != NULL) {
            switch (schedule->e) {
                case et_entry: print_entry(schedule->start_time, schedule->end_time); break;
                case et_wait_elevator: print_wait_elevator(schedule->start_time, schedule->end_time); break;
                case et_wait_room: print_wait_room(schedule->start_time, schedule->end_time, schedule->from); break;
                case et_room2room: print_room2room(schedule->start_time, schedule->end_time, schedule->from, schedule->to); break;
                case et_elevator2room: print_elevator2room(schedule->start_time, schedule->end_time, schedule->to); break;
                case et_room2elevator: print_room2elevator(schedule->start_time, schedule->end_time, schedule->from);break; 
                case et_in_room: print_in_room(schedule->start_time, schedule->end_time, schedule->from); break; 
                case et_in_elevator: print_in_elevator(schedule->start_time, schedule->end_time); break;
                case et_exit: print_exit(schedule->start_time, schedule->end_time); break;
            }
            schedule = schedule->next;
        }
        cout << endl;
    }
}
int main() {
    initialize();
    input();
    for (current_time = 0; current_time < 24 * 3600; ++current_time) {
        //处理每个客户的schedule
        for (int agent_id = 0; agent_id < 26; ++agent_id) {
            //没有该客户
            if (agent[agent_id].e == false) continue;
            //该客户该时刻还未到达
            if (current_time < agent[agent_id].entry_time + event_time[et_entry]) continue;
            //该客户该时刻已经离开
            if (current_time > agent[agent_id].exit_time) continue;
            Schedule * s = agent[agent_id].popr_schedule();
            //该顾客上一schedule还未完成
            if (current_time < s->end_time) continue;
            //该顾客上一schedule恰好完成,准备下一schedule
            if (current_time == s->end_time) {
                process(agent_id);
            }
        }
        //处理每个房间和电梯的等待队列
        for (int floor = 1; floor < 11; ++floor) {
            for (int id = 0; id < 11; ++id) {
                //电梯5秒一趟
                if (id == 0) {
                    if (current_time % 5 != 0) {
                        //所有队列继续等待
                        for (int k = 0; k < 26; ++k) {
                            if (room[floor][id].waiting_queue[k] == true) {
                                agent[k].popr_schedule()->end_time = current_time + 5 - current_time % 5 ;
                            }
                        }
                    } else {
                        //电梯来了！
                        room[floor][id].o = false;
                        if (!room[floor][id].waiting_q_empty()) {
                            //队列中的第一个进入电梯
                            int agent_id = room[floor][id].pop();
                            room[floor][id].o = true;
                            room[floor][id].free_time = current_time + 5;
                            Schedule * s = new Schedule;
                            s->e = et_in_elevator;
                            s->start_time= current_time;
                            int des = agent[agent_id].popr_schedule()->to;
                            if (des == -1) {
                                s->end_time = current_time + (floor - 1) * event_time[et_in_elevator];
                            } else {
                                s->end_time = current_time + abs(agent[agent_id].popr_schedule()->to / 100 - floor) * event_time[et_in_elevator];
                            }
                            s->from = floor * 100 + id;
                            s->to = agent[agent_id].popr_schedule()->to;
                            agent[agent_id].push_schedule(s);
                            //其余继续等候
                            for (int i = 0; i < 26; ++i) {
                                if (room[floor][id].waiting_queue[i] == true) {
                                    agent[i].popr_schedule()->end_time = current_time + 5;
                                }
                            }
                        }
                    }
                } else {
                    //是房间
                    if (room[floor][id].o == true) continue; //该房间当前有人
                    if (!room[floor][id].waiting_q_empty()) {
                        //队列第一人进入房间
                        int first_agent = room[floor][id].pop();
                        int duration = agent[first_agent].pop_plan().second;
                        Schedule * s = new Schedule;
                        s->e = et_in_room;
                        s->start_time = current_time;
                        s->end_time = current_time + duration;
                        s->from = floor * 100 + id;
                        if (agent[first_agent].plan != NULL) {
                            s->to = agent[first_agent].popr_plan().first;
                        } else {
                            s->to = -1;
                        }
                        agent[first_agent].push_schedule(s);
                        room[floor][id].o = true;
                        room[floor][id].free_time = current_time + duration;
                        //其余继续等候
                        for (int i = 0; i < 26; ++i) {
                            if (room[floor][id].waiting_queue[i] == true) {
                                agent[i].popr_schedule()->end_time = room[floor][id].free_time;
                            }
                        }
                    }
                }
            }
        }
    }
    output();
    system("pause");
    return 0;
}