POJ 1025

敝人做的第一道POJ题，丫的没想到是如此麻烦的模拟题，做了好久。最后反复TLE,自己各类数据没有问题，源测试数据没下到。

最后找牛人帮调试，终于AC。谢之。

问题出在输入上，测试数据并不按顾客优先级输入，之前对题意理解有偏差。

这道题目有只很牛逼的电梯。在5的整数倍秒打开进人，且有相位鞋的功效，不计碰撞，真tm牛逼！

我的低级代码：

 

poj 1025

1 #include < iostream >
2 #include < string >
3 #include < iomanip >
4 #include < cmath >
5 #include < algorithm >
6 #include < deque >
7 #include < vector >
8 #include < time.h >
9   using namespace std;
10
11   enum preState
12 {
13 s_Outside,
14 s_InElevator,
15 s_InRoom,
16 s_InEleQueue,
17 s_InRoomQueue,
18 s_PlanFinished,
19 };
20   struct timmme
21 {
22 friend istream & operator >> (istream & ,timmme & );
23 int hour;
24 int minute;
25 int second;
26 timmme():hour( 0 ),minute( 0 ),second( 0 ){}
27 timmme( int hr, int mt, int sd):hour(hr),minute(mt),second(sd) {}
28 void print()
29 {
30 printf( " %02d:%02d:%02d " , hour, minute, second);
31 }
32 timmme operator + ( int stay)
33 {
34 timmme tm;
35 int tmp,tmp1;
36 tmp = (second + stay) / 60 ;
37 tm.second = (second + stay) % 60 ;
38 tmp1 = (minute + tmp) / 60 ;
39 tm.minute = (minute + tmp) % 60 ;
40 tm.hour = (hour + tmp1) % 24 ;
41 return tm;
42 }
43 bool operator < (timmme & rhs)
44 {
45 if (hour < rhs.hour)
46 return true ;
47 else if (hour > rhs.hour)
48 return false ;
49 else if (minute < rhs.minute)
50 return true ;
51 else if (minute > rhs.minute)
52 return false ;
53 else if (second < rhs.second)
54 return true ;
55 else return false ;
56 }
57 timmme & operator = ( const timmme & rhs)
58 {
59 second = rhs.second;
60 minute = rhs.minute;
61 hour = rhs.hour;
62 return * this ;
63 }
64 };
65 struct task
66 {
67 friend istream & operator >> (istream & , task & );
68 string xxyy;
69 int stay;
70 bool over;
71 int getRoomNum() // 获得房间号（1-100）
72 {
73 int a = (xxyy[ 2 ] == ' 1 ' ) ? 10 : int (xxyy[ 3 ] - ' 0 ' );
74 return (getFloorNum() - 1 ) * 10 + a;
75 }
76 int getFloorNum() // 获得楼层号（1-10）
77 {
78 return (xxyy[ 0 ] == ' 1 ' ) ? 10 : int (xxyy[ 1 ] - ' 0 ' );
79 }
80 task( string xy, int st):xxyy(xy),stay(st), over( false ){}
81 task():xxyy( " 0101 " ),stay( 0 ), over( false ){}
82 };
83 struct state
84 {
85 timmme start;
86 timmme finish;
87 bool waiting;
88 string description;
89 state():waiting( false ){}
90 void print()
91 {
92 start.print();
93 printf( " " );
94 finish.print();
95 printf( " %s\n " , description.c_str());
96 }
97 };
98 class agent;
99 struct room
100 {
101 timmme freeUntil;
102 deque < agent *> roomQueue;
103 };
104 struct elevator
105 {
106 timmme freeUntil;
107 deque < agent *> eleQueue;
108 };
109 class agent
110 {
111 friend istream & operator >> (istream & , agent & );
112 public :
113 state st;
114 deque < task > plan;
115 agent():prSt(s_Outside){}
116 void SetCurrentTask() { if (plan.size()) currentTask = plan.front(); }
117 task & updateTask();
118 char & getPriority() { return priority; }
119 timmme & getBegintime() { return beginTime; }
120 preState & getPreState() { return prSt; }
121 state getState(vector < room >& , vector < elevator >& );
122 void visit(state & );
123 void print();
124 bool operator < (agent & rhs)
125 {
126 return priority < rhs.getPriority();
127 }
128 private :
129 char priority;
130 timmme beginTime;
131 task currentTask;
132 task preTask;
133 preState prSt;
134 vector < state > route;
135 };
136 task & agent::updateTask() // 更新当前任务
137 {
138 plan.pop_front();
139 return plan.front();
140 }
141
142 state agent::getState(vector < room >& rom, vector < elevator >& elevt)
143 {
144 if ( ! st.waiting) // 仅不处于等待状态的agent才更新state起始时间
145 st.start = beginTime;
146 if (currentTask.over && plan.size() == 1 ) // 标识结束访问状态,使日程size=0为结束的唯一标识
147 plan.pop_front();
148 if (currentTask.over && plan.size() > 1 ) // 仅当任务结束后更新任务
149 {
150 preTask = currentTask;
151 currentTask = updateTask();
152 }
153 room & rm = rom[currentTask.getRoomNum() - 1 ];
154 elevator & elev = elevt[currentTask.getFloorNum() - 1 ];
155 switch (prSt)
156 {
157 case s_Outside: // 前一状态：楼外
158 st.description = " Entry " ;
159 st.finish = beginTime + 30 ;
160 prSt = (currentTask.getFloorNum() == 1 ) ? s_InRoomQueue:s_InEleQueue; // 进入电梯队列或房间队列
161 break ;
162 case s_InEleQueue: // 前一状态：电梯队列
163 {
164 size_t i;
165 // 当前时间agent在电梯队列中的位置计算：
166 if (st.waiting) // 等待状态时，agent已在队列中
167 for (i = 0 ; i < elev.eleQueue.size() && elev.eleQueue[i] -> getPriority() != priority; ++ i) ;
168 else if (elev.eleQueue.size() == 0 ) // 非等待状态，队列为空，创建队列。
169 {
170 elev.eleQueue.push_front( this );
171 i = 0 ;
172 }
173 else // 非等待状态，队列非空，按优先级插入队列。
174 {
175 for (i = 0 ; i < elev.eleQueue.size() && elev.eleQueue[i] -> getPriority() < priority; ++ i) ;
176 elev.eleQueue.insert(elev.eleQueue.begin() + i, this );
177 }
178 if ( ! i &&! (beginTime < elev.freeUntil) && beginTime.second % 5 ) // 电梯每5秒打开，规格化begintime.
179 elev.freeUntil = beginTime + ( 5 - beginTime.second % 5 );
180 // agent在队首且电梯可用：
181 if ( ! i &&! (beginTime < elev.freeUntil) &&! st.waiting) // 不处于等待状态时进电梯
182 {
183 st.description = " Stay in elevator " ;
184 if (plan.size() == 0 ) // 访问结束下至01层
185 st.finish = beginTime + (currentTask.getFloorNum() - 1 ) * 30 ;
186 else st.finish = beginTime + abs(currentTask.getFloorNum() - preTask.getFloorNum()) * 30 ; // 至下一任务房间所在层
187 elev.freeUntil = beginTime + 5 ; // 更新电梯可用时间
188 elev.eleQueue.pop_front(); // 从电梯队列剔除
189 prSt = s_InElevator;
190 }
191 else if ( ! i &&! (beginTime < elev.freeUntil) && st.waiting) // 处于等待状态时，结束整个等待过程,更新state。
192 {
193 st.description = " Waiting in elevator queue " ;
194 elev.eleQueue.pop_front();
195 st.waiting = false ;
196 prSt = s_InEleQueue;
197 }
198 // agent在队首但电梯不可用，或agent不在队首，进入等待状态：
199 else
200 {
201 if ( ! i && beginTime < elev.freeUntil)
202 st.finish = elev.freeUntil;
203 else st.finish = elev.eleQueue[i - 1 ] -> getBegintime() + 5 ;
204 st.waiting = true ;
205 prSt = s_InEleQueue;
206 }
207 break ;
208 }
209 case s_InRoomQueue: // 前一状态：房间队列
210 {
211 size_t j;
212 // 当前时间agent在房间队列位置的计算：
213 if (st.waiting) // 等待状态时，agent已在队列中
214 for (j = 0 ; j < rm.roomQueue.size() && rm.roomQueue[j] -> getPriority() != priority; ++ j) ;
215 else if (rm.roomQueue.size() == 0 ) // 非等待，队列为空，创建队列
216 {
217 rm.roomQueue.push_front( this );
218 j = 0 ;
219 }
220 else // 非等待，队列非空，按优先级插入队列
221 {
222 for (j = 0 ; j < rm.roomQueue.size() && rm.roomQueue[j] -> getPriority() < priority; ++ j) ;
223 rm.roomQueue.insert(rm.roomQueue.begin() + j, this );
224 }
225 // agent在队首，且房间可用
226 if ( ! j &&! (beginTime < rm.freeUntil) &&! st.waiting) // 非等待状态时，进入房间
227 {
228 st.description = " Stay in room " + currentTask.xxyy;
229 st.finish = beginTime + currentTask.stay;
230 rm.roomQueue.pop_front(); // 从房间队列中剔除
231 rm.freeUntil = st.finish; // 更新房间可用时间
232 currentTask.over = true ; // 标记当前任务完成
233 prSt = s_InRoom;
234 }
235 else if ( ! j &&! (beginTime < rm.freeUntil) && st.waiting) // 处于等待状态时，结束整个等待过程,更新state。
236 {
237 st.description = " Waiting in front of room " + currentTask.xxyy;
238 st.waiting = false ;
239 rm.roomQueue.pop_front();
240 prSt = s_InRoomQueue;
241 }
242 // agent在队首但房间不可用，或agent不处于队首，进入等待状态
243 else
244 {
245 if ( ! j && beginTime < rm.freeUntil)
246 st.finish = rm.freeUntil;
247 else st.finish = rm.roomQueue[j - 1 ] -> getBegintime();
248 st.waiting = true ;
249 prSt = s_InRoomQueue;
250 }
251 break ;
252 }
253 case s_InElevator: // 前一状态：电梯内
254 if (plan.size() == 0 ) // 如果访问结束，exit。
255 {
256 st.description = " Exit " ;
257 st.finish = beginTime + 30 ;
258 prSt = s_PlanFinished;
259 }
260 else // 否则，进入房间队列。
261 {
262 st.description = " Transfer from elevator to room " + currentTask.xxyy;
263 st.finish = beginTime + 10 ;
264 prSt = s_InRoomQueue;
265 }
266 break ;
267 case s_InRoom: // 前一状态：房间内
268 if (plan.size() == 0 ) // 访问已结束
269 {
270 if (currentTask.getFloorNum() != 1 ) // 不在01层，进入电梯队列
271 {
272 st.description = " Transfer from room " + currentTask.xxyy + " to elevator " ;
273 st.finish = beginTime + 10 ;
274 prSt = s_InEleQueue;
275 }
276 else // 在01层，exit
277 {
278 st.description = " Exit " ;
279 st.finish = beginTime + 30 ;
280 prSt = s_PlanFinished;
281 }
282 }
283 else if (preTask.getFloorNum() != currentTask.getFloorNum()) // 下一任务房间不在同一楼层，进入电梯队列
284 {
285 st.description = " Transfer from room " + preTask.xxyy + " to elevator " ;
286 st.finish = beginTime + 10 ;
287 prSt = s_InEleQueue;
288 }
289 else // 下一任务房间在同一楼层，进入房间队列
290 {
291 st.description = " Transfer from room " + preTask.xxyy + " to room " + currentTask.xxyy;
292 st.finish = beginTime + 10 ;
293 prSt = s_InRoomQueue;
294 }
295 break ;
296 }
297 beginTime = st.finish;
298 return st;
299 }
300
301 void agent::visit(state & h)
302 {
303 if ( ! h.waiting)
304 route.push_back(h);
305 }
306 void agent::print()
307 {
308 printf( " %c\n " , priority);
309 for (size_t k = 0 ; k < route.size(); ++ k)
310 {
311 route[k].print();
312 }
313 printf( " \n " );
314 }
315 int getAgent(vector < agent >& a) // 按时间顺序获得当前待处理agent
316 {
317 int x =- 1 ;
318 int i;
319 for (i = 0 ; i < ( int )a.size() && a[i].getPreState() == s_PlanFinished; ++ i)
320 ;
321 if (i == ( int )a.size())
322 return x;
323 else
324 {
325 x = i;
326 for ( int j = x; j < ( int )a.size(); ++ j)
327 {
328 if (a[j].getPreState() != s_PlanFinished && a[j].getBegintime() < a[x].getBegintime())
329 x = j;
330 }
331 return x;
332 }
333 }
334 istream & operator >> (istream & is ,timmme & t)
335 {
336 char x;
337 is >> t.hour >> x >> t.minute >> x >> t.second;
338 return is ;
339 }
340 istream & operator >> (istream & is , task & r)
341 {
342 is >> r.xxyy;
343 if (r.xxyy == " 0 " )
344 return is ;
345 is >> r.stay;
346 return is ;
347 }
348 istream & operator >> (istream & is , agent & a)
349 {
350 task tsk;
351 is >> a.priority;
352 if (a.priority == ' . ' ) return is ;
353 is >> a.beginTime >> tsk;
354 while (tsk.xxyy != " 0 " )
355 {
356 a.plan.push_back(tsk);
357 is >> tsk;
358 }
359 return is ;
360 }
361 int main()
362 {
363 int k;
364 vector < room > rm( 100 );
365 vector < elevator > elevt( 10 );
366 vector < agent > agents;
367 agent theAgent;
368 cin >> theAgent;
369 while (theAgent.getPriority() != ' . ' )
370 {
371 agents.push_back(theAgent);
372 theAgent.plan.clear();
373 cin >> theAgent;
374 }
375
376 sort(agents.begin(), agents.end()); // 按优先级将agent排序以便于getAgent.
377 for (size_t i = 0 ; i < agents.size(); ++ i)
378 {
379 agents[i].SetCurrentTask();
380 }
381 k = getAgent(agents);
382 while (k + 1 )
383 {
384 state s = agents[k].getState(rm,elevt);
385 agents[k].visit(s);
386 k = getAgent(agents);
387 }
388 for (size_t i = 0 ; i < agents.size(); ++ i)
389 {
390 agents[i].print();
391 }
392 }
393

 

 

 

 

 

 

转载于:https://www.cnblogs.com/gmlfly/archive/2011/01/13/1934972.html