医院设备利用（Use of Hospital Facilities, ACM/ICPC World Finals 1991, UVa212）rust解法

医院里有n（n≤10）个手术室和m（m≤30）个恢复室。每个病人首先会被分配到一个手术室，手术后会被分配到一个恢复室。从任意手术室到任意恢复室的时间均为t1，准备一个手术室和恢复室的时间分别为t2和t3（一开始所有手术室和恢复室均准备好，只有接待完一个病人之后才需要为下一个病人准备）。
k名（k≤100）病人按照花名册顺序排队，T点钟准时开放手术室。每当有准备好的手术室时，队首病人进入其中编号最小的手术室。手术结束后，病人应立刻进入编号最小的恢复室。如果有多个病人同时结束手术，在编号较小的手术室做手术的病人优先进入编号较小的恢复室。输入保证病人无须排队等待恢复室。
输入n、m、T、t1、t2、t3、k和k名病人的名字、手术时间和恢复时间，模拟这个过程。

样例：
输入

5 12 07 5 15 10 16
Jones
28 140
Smith
120 200
Thompson
23 75
Albright
19 82
Poucher
133 209
Comer
74 101
Perry
93 188
Page
111 223
Roggio
69 122
Brigham
42 79
Nute
22 71
Young
38 140
Bush
26 121
Cates
120 248
Johnson
86 181
White
92 140
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

输出

 Patient          Operating Room          Recovery Room
 #  Name     Room#  Begin   End      Bed#  Begin    End
 ------------------------------------------------------
 1  Jones      1    7:00    7:28      3    7:33    9:53
 2  Smith      2    7:00    9:00      1    9:05   12:25
 3  Thompson   3    7:00    7:23      2    7:28    8:43
 4  Albright   4    7:00    7:19      1    7:24    8:46
 5  Poucher    5    7:00    9:13      5    9:18   12:47
 6  Comer      4    7:34    8:48      4    8:53   10:34
 7  Perry      3    7:38    9:11      2    9:16   12:24
 8  Page       1    7:43    9:34      6    9:39   13:22
 9  Roggio     4    9:03   10:12      9   10:17   12:19
10  Brigham    2    9:15    9:57      8   10:02   11:21
11  Nute       3    9:26    9:48      7    9:53   11:04
12  Young      5    9:28   10:06      3   10:11   12:31
13  Bush       1    9:49   10:15     10   10:20   12:21
14  Cates      3   10:03   12:03      8   12:08   16:16
15  Johnson    2   10:12   11:38      4   11:43   14:44
16  White      5   10:21   11:53      7   11:58   14:18

Facility Utilization
Type  # Minutes  % Used
-------------------------
Room  1     165   29.68
Room  2     248   44.60
Room  3     258   46.40
Room  4     162   29.14
Room  5     263   47.30
Bed   1     282   50.72
Bed   2     263   47.30
Bed   3     280   50.36
Bed   4     282   50.72
Bed   5     209   37.59
Bed   6     223   40.11
Bed   7     211   37.95
Bed   8     327   58.81
Bed   9     122   21.94
Bed  10     121   21.76
Bed  11       0    0.00
Bed  12       0    0.00
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

解法：

use std::{cmp::Ordering, collections::BinaryHeap, io};
#[derive(Debug)]
struct Patient {
    id: usize,
    name: String,
    operation_time: usize,
    recovery_time: usize,
    room_id: usize,
    room_begin_time: usize,
    room_end_time: usize,
    bed_id: usize,
    bed_begin_time: usize,
    bed_end_time: usize,
}
#[derive(Debug, PartialEq, Eq)]
struct Room {
    id: usize,
    start_available_time: usize,
}
impl Ord for Room {
    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
        if self.start_available_time != other.start_available_time {
            other.start_available_time.cmp(&self.start_available_time)
        } else {
            other.id.cmp(&self.id)
        }
    }
}
impl PartialOrd for Room {
    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
        Some(self.cmp(other))
    }
}

fn main() {
    let mut buf = String::new();
    io::stdin().read_line(&mut buf).unwrap();
    let v: Vec<usize> = buf.split_whitespace().map(|e| e.parse().unwrap()).collect();
    let n = v[0];
    let m = v[1];
    let start_time = v[2] * 60;
    let t1 = v[3];
    let t2 = v[4];
    let t3 = v[5];
    let k = v[6];
    let mut rooms = BinaryHeap::new();
    for i in 0..n {
        let room = Room {
            id: i + 1,
            start_available_time: start_time,
        };
        rooms.push(room);
    }

    let mut patients: Vec<Patient> = vec![];
    for i in 0..k {
        let mut buf = String::new();
        io::stdin().read_line(&mut buf).unwrap();
        let name = buf.trim().to_string();
        let mut buf = String::new();
        io::stdin().read_line(&mut buf).unwrap();
        let t: Vec<usize> = buf.split_whitespace().map(|e| e.parse().unwrap()).collect();

        let patient = Patient {
            id: i + 1,
            name: name,
            operation_time: t[0],
            recovery_time: t[1],
            room_id: 0,
            room_begin_time: 0,
            room_end_time: 0,
            bed_id: 0,
            bed_begin_time: 0,
            bed_end_time: 0,
        };
        patients.push(patient);
    }
    let mut room_used_time: Vec<usize> = vec![0; n];
    for patient in patients.iter_mut() {
        let aroom = rooms.pop().unwrap();
        patient.room_id = aroom.id;
        patient.room_begin_time = aroom.start_available_time;
        patient.room_end_time = patient.room_begin_time + patient.operation_time;
        rooms.push(Room {
            id: aroom.id,
            start_available_time: patient.room_end_time + t2,
        });
        room_used_time[aroom.id - 1] += patient.operation_time;
    }

    patients.sort_by(|a, b| {
        if a.room_end_time != b.room_end_time {
            a.room_end_time.cmp(&b.room_end_time)
        } else {
            a.room_id.cmp(&b.room_id)
        }
    });

    let mut beds: Vec<usize> = vec![start_time; m];
    let mut bed_used_time: Vec<usize> = vec![0; m];
    let mut final_time = start_time;
    for patient in patients.iter_mut() {
        for j in 0..m {
            if beds[j] <= patient.room_end_time {
                patient.bed_id = j + 1;
                patient.bed_begin_time = patient.room_end_time + t1;
                patient.bed_end_time = patient.bed_begin_time + patient.recovery_time;
                beds[j] = patient.bed_end_time + t3;
                bed_used_time[j] += patient.recovery_time;
                final_time = final_time.max(patient.bed_end_time);
                break;
            }
        }
    }
    patients.sort_by(|a, b| a.id.cmp(&b.id));
    println!(" Patient          Operating Room          Recovery Room");
    println!(" #  Name     Room#  Begin   End      Bed#  Begin    End");
    println!(" ------------------------------------------------------");
    for i in patients.iter() {
        print!("{:2}  {:<10}", i.id, i.name);
        print!(
            "{:2}   {:2}:{:02}   {:2}:{:02}",
            i.room_id,
            i.room_begin_time / 60,
            i.room_begin_time % 60,
            i.room_end_time / 60,
            i.room_end_time % 60
        );
        println!(
            "     {:2}   {:2}:{:02}   {:2}:{:02}",
            i.bed_id,
            i.bed_begin_time / 60,
            i.bed_begin_time % 60,
            i.bed_end_time / 60,
            i.bed_end_time % 60
        );
    }
    println!();
    println!("Facility Utilization");
    println!("Type  # Minutes  % Used");
    println!("-------------------------");

    let all_time = final_time - start_time;
    for i in 0..n {
        println!(
            "Room {:2}    {:4}   {:5.2}",
            i + 1,
            room_used_time[i],
            100.0 * room_used_time[i] as f64 / all_time as f64
        );
    }
    for i in 0..m {
        println!(
            "Bed  {:2}    {:4}   {:5.2}",
            i + 1,
            bed_used_time[i],
            100.0 * bed_used_time[i] as f64 / all_time as f64
        );
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160