엘리베이터 한 대가 1층부터 F층까지 오르내린다. 한 번에 K명까지 탈 수 있다.
손님 n명이 있고, 입력 차례대로 1번부터 n번이다. i번 손님은 t_i분에 a_i층에 와서 b_i층으로 가려 한다.
엘리베이터의 방향은 '위', '아래', '멈춤' 가운데 하나다. 시각 0분에 엘리베이터는 1층에 비어 있고, 방향은 '멈춤'이다.
지금 시각이 T분, 엘리베이터가 f층에 있을 때 다음 다섯 단계를 차례로 한다.
1단계: 시각 T에 온 손님이 자기 층의 줄 맨 뒤에 선다. 같은 시각에 온 손님은 번호 순으로 선다.
2단계: 타고 있는 손님 가운데 f층으로 가는 손님이 모두 내린다. 이 손님들이 도착한 시각은 T다.
3단계: 방향을 정한다. '위쪽 일'이 있다는 것은 f층보다 위로 가는 탄 손님, f층보다 위층에서 기다리는 손님, f층에서 기다리며 위로 가려는 손님 가운데 하나라도 있다는 뜻이다. '아래쪽 일'도 같은 식으로 아래쪽을 본다.
- 방향이 '위'이고 위쪽 일이 있으면 '위'를 그대로 둔다. 위쪽 일이 없으면, 아래쪽 일이 있을 때 '아래'로, 없을 때 '멈춤'으로 바꾼다.
- 방향이 '아래'일 때도 같은 식이다. 아래쪽 일이 있으면 그대로 두고, 없으면 위쪽 일이 있을 때 '위'로, 없을 때 '멈춤'으로 바꾼다.
- 방향이 '멈춤'이면, 지금 기다리는 손님 가운데 번호가 가장 작은 손님 P를 본다. P가 다른 층에 있으면 P가 있는 층 쪽으로, P가 f층에 있으면 P가 가려는 쪽으로 방향을 정한다. 기다리는 손님이 없으면 '멈춤'으로 둔다. 가까운 손님이 아니라 번호가 가장 작은 손님이다.
4단계: 방향이 '멈춤'이 아니면, f층 줄에서 그 방향으로 가려는 손님이 줄 선 차례대로 탄다. 타고 있는 사람이 K명이면 더 타지 못한다. 못 탄 손님과 다른 방향으로 가려는 손님은 줄 선 차례를 지키며 계속 기다린다.
5단계: 방향이 '위'면 한 층 올라가고, '아래'면 한 층 내려가서 시각 T + 1이 된다. 방향이 '멈춤'이면 그 층에 그대로 있고, 다음 손님이 오는 시각으로 건너뛴다.
모든 손님이 도착하면 끝난다.
첫 줄에 F, K, n이, 다음 n줄에 t_i, a_i, b_i가 빈칸 하나씩으로 나뉘어 주어진다.
손님마다 도착한 시각을 번호 순으로 한 줄에 하나씩 출력하라.
입력
2 ≤ F ≤ 30, 1 ≤ K ≤ 10, 1 ≤ n ≤ 500, 0 ≤ t_i ≤ 1,000,000, 1 ≤ a_i, b_i ≤ F, a_i ≠ b_i(모두 정수). t_i는 번호가 커질수록 줄지 않는다.
출력
n줄, 손님마다 도착한 시각
예시 1 · stdin
6 2 5
0 1 4
0 3 1
1 2 5
2 5 3
2 6 5
stdout
3
10
4
8
6
main.py
오류 목록00F8 ↓ · ⇧F8 ↑
입력(stdin)
실행하면 이 줄들이 차례로 input()·표준 입력으로 들어가요(실행 중에 묻지 않아요).
$ 준비됐어요
코드를 입력해 풀려면 PC에서 열어 주세요. 모바일에서는 문제와 풀이를 볼 수 있어요.
다른 언어로는?언어별 풀이 보기 · 8개 언어 풀이
규칙을 한 단계씩 그대로 옮기는 시뮬레이션이에요. 층마다 기다리는 줄(목록의 목록)과 탄 사람 목록을 들고, 매 분 다섯 단계를 차례로 돌려요. 할 일이 없을 때 1분씩 세면 100만 분을 헛돌게 되니, '멈춤'이면 다음 손님이 오는 시각으로 바로 건너뛰어요. 탄 사람 목록에서 내리는 사람을 빼는 방법이 언어마다 달라요: Python은 리스트 내포로 새 목록, JS·TS filter, Java는 Iterator.remove()(for-each 안에서 list.remove를 하면 대개 ConcurrentModificationException이 나요), C#은 RemoveAll(p => …)(foreach 안에서 지우면 InvalidOperationException), C는 남는 사람을 배열 앞으로 당겨 담고 개수를 줄이기, C++20 std::erase_if, 크레이콘은 남은 사람으로 새 목록을 만들어요. 줄에서 타는 사람을 뺄 때도 남은 사람의 차례를 지키며 새 줄을 만들어요. 함정 여섯: ① 가는 방향을 보지 않고 모두 태우면 반대로 갈 손님이 함께 끌려가요. ② 타기를 내리기보다 먼저 하면 꽉 찬 채로 태우려 해서, 그 층에서 내릴 자리가 있었는데도 못 타요. ③ 멈춰 있을 때 가장 가까운 손님 쪽으로 가면 틀려요. 번호가 가장 작은 손님 쪽이에요. ④ 맨 끝 층까지 갔다가 돌아서면(SCAN) 틀려요. 이 문제는 더 갈 일이 없으면 그 자리에서 돌아서요(LOOK). ⑤ 자리 수를 <= K로 비교하면 한 명 더 타요. ⑥ 멈춰 있을 때 P가 다른 층에 있는데 P의 목적지 쪽으로 출발하면 P를 데리러 가지 않아요.
Pythonmain.py · 59 줄
import sysdef main(): data = sys.stdin.read().split() floors, cap, n = int(data[0]), int(data[1]), int(data[2]) t = [int(data[3 + 3 * i]) for i in range(n)] a = [int(data[4 + 3 * i]) for i in range(n)] b = [int(data[5 + 3 * i]) for i in range(n)] waiting = [[] for _ in range(floors + 1)] # 층마다 기다리는 사람 번호(온 차례) inside = [] # 타고 있는 사람 번호 arrive = [0] * n now, floor, direction = 0, 1, 0 # 방향: 1 위, -1 아래, 0 멈춤 nxt = done = 0 while done < n: # 1) 이 시각에 온 사람이 줄을 선다 while nxt < n and t[nxt] == now: waiting[a[nxt]].append(nxt) nxt += 1 # 2) 내릴 사람이 내린다 for p in [p for p in inside if b[p] == floor]: arrive[p] = now done += 1 inside = [p for p in inside if b[p] != floor] # 3) 방향을 정한다 up = any(b[p] > floor for p in inside) or any(waiting[g] for g in range(floor + 1, floors + 1)) \ or any(b[p] > floor for p in waiting[floor]) down = any(b[p] < floor for p in inside) or any(waiting[g] for g in range(1, floor)) \ or any(b[p] < floor for p in waiting[floor]) if direction == 1 and not up: direction = -1 if down else 0 elif direction == -1 and not down: direction = 1 if up else 0 elif direction == 0: first = min((p for g in range(1, floors + 1) for p in waiting[g]), default=None) if first is not None: target = a[first] if a[first] != floor else b[first] direction = 1 if target > floor else -1 # 4) 같은 방향으로 갈 사람이 온 차례대로, 자리가 있는 만큼 탄다 if direction != 0: stay = [] for p in waiting[floor]: if (b[p] - floor) * direction > 0 and len(inside) < cap: inside.append(p) else: stay.append(p) waiting[floor] = stay if done == n: break # 5) 한 층 옮긴다. 할 일이 없으면 다음 사람이 올 때까지 건너뛴다 if direction == 0: now = t[nxt] else: floor += direction now += 1 print("\n".join(map(str, arrive)))main()
JavaScriptmain.js · 55 줄
const d = require("fs").readFileSync(0, "utf8").trim().split(/\s+/).map(Number);const [floors, cap, n] = d;const t = [], a = [], b = [];for (let i = 0; i < n; i++) { t.push(d[3 + 3 * i]); a.push(d[4 + 3 * i]); b.push(d[5 + 3 * i]);}let waiting = Array.from({ length: floors + 1 }, () => []); // 층마다 기다리는 사람 번호(온 차례)let inside = []; // 타고 있는 사람 번호const arrive = new Array(n).fill(0);let now = 0, floor = 1, dir = 0; // 방향: 1 위, -1 아래, 0 멈춤let next = 0, done = 0;while (done < n) { // 1) 이 시각에 온 사람이 줄을 선다 while (next < n && t[next] === now) waiting[a[next]].push(next++); // 2) 내릴 사람이 내린다 for (const p of inside) if (b[p] === floor) { arrive[p] = now; done++; } inside = inside.filter((p) => b[p] !== floor); // 3) 방향을 정한다 let up = inside.some((p) => b[p] > floor) || waiting[floor].some((p) => b[p] > floor); let down = inside.some((p) => b[p] < floor) || waiting[floor].some((p) => b[p] < floor); for (let g = 1; g <= floors; g++) { if (waiting[g].length === 0) continue; if (g > floor) up = true; if (g < floor) down = true; } if (dir === 1 && !up) dir = down ? -1 : 0; else if (dir === -1 && !down) dir = up ? 1 : 0; else if (dir === 0) { let first = -1; // 기다리는 사람 가운데 가장 먼저 온 사람 for (let g = 1; g <= floors; g++) if (waiting[g].length > 0 && (first < 0 || waiting[g][0] < first)) first = waiting[g][0]; if (first >= 0) { const target = a[first] !== floor ? a[first] : b[first]; dir = target > floor ? 1 : -1; } } // 4) 같은 방향으로 갈 사람이 온 차례대로, 자리가 있는 만큼 탄다 if (dir !== 0) { const stay = []; for (const p of waiting[floor]) { if ((b[p] - floor) * dir > 0 && inside.length < cap) inside.push(p); else stay.push(p); } waiting[floor] = stay; } if (done === n) break; // 5) 한 층 옮긴다. 할 일이 없으면 다음 사람이 올 때까지 건너뛴다 if (dir === 0) now = t[next]; else { floor += dir; now++; }}console.log(arrive.join("\n"));
TypeScriptmain.ts · 55 줄
const d: number[] = require("fs").readFileSync(0, "utf8").trim().split(/\s+/).map(Number);const [floors, cap, n] = d;const t: number[] = [], a: number[] = [], b: number[] = [];for (let i = 0; i < n; i++) { t.push(d[3 + 3 * i]); a.push(d[4 + 3 * i]); b.push(d[5 + 3 * i]);}let waiting: number[][] = Array.from({ length: floors + 1 }, () => []); // 층마다 기다리는 사람 번호(온 차례)let inside: number[] = []; // 타고 있는 사람 번호const arrive: number[] = new Array(n).fill(0);let now = 0, floor = 1, dir = 0; // 방향: 1 위, -1 아래, 0 멈춤let next = 0, done = 0;while (done < n) { // 1) 이 시각에 온 사람이 줄을 선다 while (next < n && t[next] === now) waiting[a[next]].push(next++); // 2) 내릴 사람이 내린다 for (const p of inside) if (b[p] === floor) { arrive[p] = now; done++; } inside = inside.filter((p) => b[p] !== floor); // 3) 방향을 정한다 let up = inside.some((p) => b[p] > floor) || waiting[floor].some((p) => b[p] > floor); let down = inside.some((p) => b[p] < floor) || waiting[floor].some((p) => b[p] < floor); for (let g = 1; g <= floors; g++) { if (waiting[g].length === 0) continue; if (g > floor) up = true; if (g < floor) down = true; } if (dir === 1 && !up) dir = down ? -1 : 0; else if (dir === -1 && !down) dir = up ? 1 : 0; else if (dir === 0) { let first = -1; // 기다리는 사람 가운데 가장 먼저 온 사람 for (let g = 1; g <= floors; g++) if (waiting[g].length > 0 && (first < 0 || waiting[g][0] < first)) first = waiting[g][0]; if (first >= 0) { const target = a[first] !== floor ? a[first] : b[first]; dir = target > floor ? 1 : -1; } } // 4) 같은 방향으로 갈 사람이 온 차례대로, 자리가 있는 만큼 탄다 if (dir !== 0) { const stay: number[] = []; for (const p of waiting[floor]) { if ((b[p] - floor) * dir > 0 && inside.length < cap) inside.push(p); else stay.push(p); } waiting[floor] = stay; } if (done === n) break; // 5) 한 층 옮긴다. 할 일이 없으면 다음 사람이 올 때까지 건너뛴다 if (dir === 0) now = t[next]; else { floor += dir; now++; }}console.log(arrive.join("\n"));
JavaMain.java · 83 줄
import java.io.*;import java.util.*;public class Main { public static void main(String[] args) throws IOException { StreamTokenizer in = new StreamTokenizer(new BufferedInputStream(System.in)); in.nextToken(); int floors = (int) in.nval; in.nextToken(); int cap = (int) in.nval; in.nextToken(); int n = (int) in.nval; int[] t = new int[n], a = new int[n], b = new int[n]; for (int i = 0; i < n; i++) { in.nextToken(); t[i] = (int) in.nval; in.nextToken(); a[i] = (int) in.nval; in.nextToken(); b[i] = (int) in.nval; } List<List<Integer>> waiting = new ArrayList<>(); // 층마다 기다리는 사람 번호(온 차례) for (int g = 0; g <= floors; g++) waiting.add(new ArrayList<>()); List<Integer> inside = new ArrayList<>(); int[] arrive = new int[n]; int now = 0, floor = 1, dir = 0; // 방향: 1 위, -1 아래, 0 멈춤 int next = 0, done = 0; while (done < n) { // 1) 이 시각에 온 사람이 줄을 선다 while (next < n && t[next] == now) waiting.get(a[next]).add(next++); // 2) 내릴 사람이 내린다 for (Iterator<Integer> it = inside.iterator(); it.hasNext(); ) { int p = it.next(); if (b[p] == floor) { arrive[p] = now; done++; it.remove(); } } // 3) 방향을 정한다 boolean up = false, down = false; for (int p : inside) { if (b[p] > floor) up = true; if (b[p] < floor) down = true; } for (int p : waiting.get(floor)) { if (b[p] > floor) up = true; if (b[p] < floor) down = true; } for (int g = 1; g <= floors; g++) { if (waiting.get(g).isEmpty()) continue; if (g > floor) up = true; if (g < floor) down = true; } if (dir == 1 && !up) dir = down ? -1 : 0; else if (dir == -1 && !down) dir = up ? 1 : 0; else if (dir == 0) { int first = -1; for (int g = 1; g <= floors; g++) { List<Integer> w = waiting.get(g); if (!w.isEmpty() && (first < 0 || w.get(0) < first)) first = w.get(0); } if (first >= 0) { int target = a[first] != floor ? a[first] : b[first]; dir = target > floor ? 1 : -1; } } // 4) 같은 방향으로 갈 사람이 온 차례대로, 자리가 있는 만큼 탄다 if (dir != 0) { List<Integer> stay = new ArrayList<>(); for (int p : waiting.get(floor)) { if ((b[p] - floor) * dir > 0 && inside.size() < cap) inside.add(p); else stay.add(p); } waiting.set(floor, stay); } if (done == n) break; // 5) 한 층 옮긴다. 할 일이 없으면 다음 사람이 올 때까지 건너뛴다 if (dir == 0) now = t[next]; else { floor += dir; now++; } } StringBuilder sb = new StringBuilder(); for (int x : arrive) sb.append(x).append('\n'); System.out.print(sb); }}
C#Main.cs · 75 줄
using System;using System.Collections.Generic;using System.Text;class Program{ static void Main() { var d = Array.ConvertAll(Console.In.ReadToEnd().Split((char[])null, StringSplitOptions.RemoveEmptyEntries), int.Parse); int floors = d[0], cap = d[1], n = d[2]; int[] t = new int[n], a = new int[n], b = new int[n]; for (int i = 0; i < n; i++) { t[i] = d[3 + 3 * i]; a[i] = d[4 + 3 * i]; b[i] = d[5 + 3 * i]; } var waiting = new List<int>[floors + 1]; // 층마다 기다리는 사람 번호(온 차례) for (int g = 0; g <= floors; g++) waiting[g] = new List<int>(); var inside = new List<int>(); var arrive = new int[n]; int now = 0, floor = 1, dir = 0; // 방향: 1 위, -1 아래, 0 멈춤 int next = 0, done = 0; while (done < n) { // 1) 이 시각에 온 사람이 줄을 선다 while (next < n && t[next] == now) { waiting[a[next]].Add(next); next++; } // 2) 내릴 사람이 내린다 foreach (int p in inside) if (b[p] == floor) { arrive[p] = now; done++; } inside.RemoveAll(p => b[p] == floor); // 3) 방향을 정한다 bool up = false, down = false; foreach (int p in inside) { if (b[p] > floor) up = true; if (b[p] < floor) down = true; } foreach (int p in waiting[floor]) { if (b[p] > floor) up = true; if (b[p] < floor) down = true; } for (int g = 1; g <= floors; g++) { if (waiting[g].Count == 0) continue; if (g > floor) up = true; if (g < floor) down = true; } if (dir == 1 && !up) dir = down ? -1 : 0; else if (dir == -1 && !down) dir = up ? 1 : 0; else if (dir == 0) { int first = -1; for (int g = 1; g <= floors; g++) if (waiting[g].Count > 0 && (first < 0 || waiting[g][0] < first)) first = waiting[g][0]; if (first >= 0) { int target = a[first] != floor ? a[first] : b[first]; dir = target > floor ? 1 : -1; } } // 4) 같은 방향으로 갈 사람이 온 차례대로, 자리가 있는 만큼 탄다 if (dir != 0) { var stay = new List<int>(); foreach (int p in waiting[floor]) { if ((b[p] - floor) * dir > 0 && inside.Count < cap) inside.Add(p); else stay.Add(p); } waiting[floor] = stay; } if (done == n) break; // 5) 한 층 옮긴다. 할 일이 없으면 다음 사람이 올 때까지 건너뛴다 if (dir == 0) now = t[next]; else { floor += dir; now++; } } var sb = new StringBuilder(); foreach (int x in arrive) sb.Append(x).Append('\n'); Console.Write(sb); }}
C++main.cpp · 59 줄
#include <algorithm>#include <iostream>#include <vector>int main() { std::ios::sync_with_stdio(false); std::cin.tie(nullptr); int floors, cap, n; std::cin >> floors >> cap >> n; std::vector<int> t(n), a(n), b(n), arrive(n); for (int i = 0; i < n; i++) std::cin >> t[i] >> a[i] >> b[i]; std::vector<std::vector<int>> waiting(floors + 1); // 층마다 기다리는 사람 번호(온 차례) std::vector<int> inside; int now = 0, floor = 1, dir = 0; // 방향: 1 위, -1 아래, 0 멈춤 int next = 0, done = 0; while (done < n) { // 1) 이 시각에 온 사람이 줄을 선다 while (next < n && t[next] == now) waiting[a[next]].push_back(next), next++; // 2) 내릴 사람이 내린다 for (int p : inside) if (b[p] == floor) arrive[p] = now, done++; std::erase_if(inside, [&](int p) { return b[p] == floor; }); // 3) 방향을 정한다 bool up = false, down = false; for (int p : inside) up |= b[p] > floor, down |= b[p] < floor; for (int p : waiting[floor]) up |= b[p] > floor, down |= b[p] < floor; for (int g = 1; g <= floors; g++) { if (waiting[g].empty()) continue; if (g > floor) up = true; if (g < floor) down = true; } if (dir == 1 && !up) dir = down ? -1 : 0; else if (dir == -1 && !down) dir = up ? 1 : 0; else if (dir == 0) { int first = -1; for (int g = 1; g <= floors; g++) if (!waiting[g].empty() && (first < 0 || waiting[g][0] < first)) first = waiting[g][0]; if (first >= 0) { int target = a[first] != floor ? a[first] : b[first]; dir = target > floor ? 1 : -1; } } // 4) 같은 방향으로 갈 사람이 온 차례대로, 자리가 있는 만큼 탄다 if (dir != 0) { std::vector<int> stay; for (int p : waiting[floor]) { if ((b[p] - floor) * dir > 0 && (int)inside.size() < cap) inside.push_back(p); else stay.push_back(p); } waiting[floor] = stay; } if (done == n) break; // 5) 한 층 옮긴다. 할 일이 없으면 다음 사람이 올 때까지 건너뛴다 if (dir == 0) now = t[next]; else floor += dir, now++; } for (int x : arrive) std::cout << x << '\n'; return 0;}
Cmain.c · 83 줄
#include <stdio.h>#define MAXN 500#define MAXF 30static int t[MAXN], a[MAXN], b[MAXN], arrive[MAXN];static int waiting[MAXF + 1][MAXN]; /* 층마다 기다리는 사람 번호(온 차례) */static int wcount[MAXF + 1];static int inside[10], icount = 0; /* 타고 있는 사람 번호 */int main(void) { int floors, cap, n; scanf("%d %d %d", &floors, &cap, &n); for (int i = 0; i < n; i++) scanf("%d %d %d", &t[i], &a[i], &b[i]); int now = 0, floor = 1, dir = 0; /* 방향: 1 위, -1 아래, 0 멈춤 */ int next = 0, done = 0; while (done < n) { /* 1) 이 시각에 온 사람이 줄을 선다 */ while (next < n && t[next] == now) { waiting[a[next]][wcount[a[next]]++] = next; next++; } /* 2) 내릴 사람이 내린다(남는 사람은 앞으로 당겨 담는다) */ int k = 0; for (int j = 0; j < icount; j++) { int p = inside[j]; if (b[p] == floor) { arrive[p] = now; done++; } else { inside[k++] = p; } } icount = k; /* 3) 방향을 정한다 */ int up = 0, down = 0; for (int j = 0; j < icount; j++) { if (b[inside[j]] > floor) up = 1; if (b[inside[j]] < floor) down = 1; } for (int j = 0; j < wcount[floor]; j++) { if (b[waiting[floor][j]] > floor) up = 1; if (b[waiting[floor][j]] < floor) down = 1; } for (int g = 1; g <= floors; g++) { if (wcount[g] == 0) continue; if (g > floor) up = 1; if (g < floor) down = 1; } if (dir == 1 && !up) dir = down ? -1 : 0; else if (dir == -1 && !down) dir = up ? 1 : 0; else if (dir == 0) { int first = -1; for (int g = 1; g <= floors; g++) if (wcount[g] > 0 && (first < 0 || waiting[g][0] < first)) first = waiting[g][0]; if (first >= 0) { int target = a[first] != floor ? a[first] : b[first]; dir = target > floor ? 1 : -1; } } /* 4) 같은 방향으로 갈 사람이 온 차례대로, 자리가 있는 만큼 탄다 */ if (dir != 0) { int *w = waiting[floor]; k = 0; for (int j = 0; j < wcount[floor]; j++) { int p = w[j]; if ((b[p] - floor) * dir > 0 && icount < cap) inside[icount++] = p; else w[k++] = p; } wcount[floor] = k; } if (done == n) break; /* 5) 한 층 옮긴다. 할 일이 없으면 다음 사람이 올 때까지 건너뛴다 */ if (dir == 0) { now = t[next]; } else { floor += dir; now++; } } for (int i = 0; i < n; i++) printf("%d\n", arrive[i]); return 0;}
Craykonmain.cray · 146 줄
첫줄 = 콘솔.수들읽기();floors = 첫줄[0];cap = 첫줄[1];n = 첫줄[2];t = [];a = [];b = [];반복 (i = 0; i < n; i++){ p = 콘솔.수들읽기(); t.넣기(p[0]); a.넣기(p[1]); b.넣기(p[2]);}waiting = []; // 층마다 기다리는 사람 번호(온 차례)반복 (g = 0; g <= floors; g++){ waiting.넣기([]);}inside = []; // 타고 있는 사람 번호arrive = 새목록(n, 0);now = 0;floor = 1;dir = 0; // 방향: 1 위, -1 아래, 0 멈춤next = 0;done = 0;동안 (done < n){ // 1) 이 시각에 온 사람이 줄을 선다 동안 (next < n && t[next] == now) { waiting[a[next]].넣기(next); next++; } // 2) 내릴 사람이 내린다 남은 = []; 각각 (p 에서 inside) { 만약 (b[p] == floor) { arrive[p] = now; done++; } 아니면 { 남은.넣기(p); } } inside = 남은; // 3) 방향을 정한다 up = 거짓; down = 거짓; 각각 (p 에서 inside) { 만약 (b[p] > floor) { up = 참; } 만약 (b[p] < floor) { down = 참; } } 각각 (p 에서 waiting[floor]) { 만약 (b[p] > floor) { up = 참; } 만약 (b[p] < floor) { down = 참; } } 반복 (g = 1; g <= floors; g++) { 만약 (waiting[g].개수 > 0 && g > floor) { up = 참; } 만약 (waiting[g].개수 > 0 && g < floor) { down = 참; } } 만약 (dir == 1 && !up) { dir = down ? -1 : 0; } 아니면 만약 (dir == -1 && !down) { dir = up ? 1 : 0; } 아니면 만약 (dir == 0) { first = -1; // 기다리는 사람 가운데 가장 먼저 온 사람 반복 (g = 1; g <= floors; g++) { 만약 (waiting[g].개수 > 0 && (first < 0 || waiting[g][0] < first)) { first = waiting[g][0]; } } 만약 (first >= 0) { target = a[first]; 만약 (target == floor) { target = b[first]; } dir = target > floor ? 1 : -1; } } // 4) 같은 방향으로 갈 사람이 온 차례대로, 자리가 있는 만큼 탄다 만약 (dir != 0) { stay = []; 각각 (p 에서 waiting[floor]) { 만약 ((b[p] - floor) * dir > 0 && inside.개수 < cap) { inside.넣기(p); } 아니면 { stay.넣기(p); } } waiting[floor] = stay; } 만약 (done == n) { 그만; } // 5) 한 층 옮긴다. 할 일이 없으면 다음 사람이 올 때까지 건너뛴다 만약 (dir == 0) { now = t[next]; } 아니면 { floor = floor + dir; now++; }}콘솔.쓰기(arrive.잇기("\n"));