本文深入探讨了一种用于安排会议的算法，重点是如何在考虑到多个助教（TA）的任务时间表后，找出至少两名TA可用的时段，以进行会议。算法首先确保同一TA的任务时间不重叠，接着通过记录每个TA的任务数、开始和结束时间，实现对所有时间点的排序和遍历，以判断是否有足够数量的TA空闲。此外，文章详细介绍了如何判断一个时间点上哪些TA是空闲的，以及如何计算空闲时间段是否超过一小时的方法。
题意：
input：
第一行一个数T（T≤100），表示数据组数。
对于每组数据，第一行一个数m（2 ≤ m ≤ 20），表示TA的数量。
对于每位TA，首先是一个数n（0≤ n≤100），表示该TA的任务数。接下来n行，表示各个任务的信息，格式如下
YYYY MM DD hh mm ss YYYY MM DD hh mm ss “some string here”
每一行描述的信息为：开始时间的年、月、日、时、分、秒；结束时间的年、月、日、时、分、秒，以及一些字符串，描述任务的信息。
数据约定：
所有的数据信息均为固定位数，位数不足的在在前面补前导0，数据之间由空格隔开。
描述信息的字符串中间可能包含空格，且总长度不超过100。
所有的日期时间均在1800年1月1日00:00:00到2200年1月1日00:00:00之间。
为了简化问题，我们假定所有的月份（甚至2月）均是30天的，数据保证不含有不合法的日期。
注意每件事务的结束时间点也即是该成员可以开始参与开会的时间点。注：（题目中我没有明确看到，但同学们的时候，说是每个人的任务的时间是递增给出来的，这让在判断的时候也带来了方便。）
output：
样例输入：
2
3
3
2020 06 28 15 00 00 2020 06 28 18 00 00 TT study
2020 06 29 10 00 00 2020 06 29 15 00 00 TT solving problems
2020 11 15 15 00 00 2020 11 17 23 00 00 TT play with his magic cat
4
2020 06 25 13 30 00 2020 06 25 15 30 00 hrz play
2020 06 26 13 30 00 2020 06 26 15 30 00 hrz study
2020 06 29 13 00 00 2020 06 29 15 00 00 hrz debug
2020 06 30 13 00 00 2020 06 30 15 00 00 hrz play
1
2020 06 01 00 00 00 2020 06 29 18 00 00 zjm study
2
1
1800 01 01 00 00 00 2200 01 01 00 00 00 sleep
0样例输入：
Scenario #1:
appointment possible from 01/01/1800 00:00:00 to 06/25/2020 13:30:00
appointment possible from 06/25/2020 15:30:00 to 06/26/2020 13:30:00
appointment possible from 06/26/2020 15:30:00 to 06/28/2020 15:00:00
appointment possible from 06/28/2020 18:00:00 to 06/29/2020 10:00:00
appointment possible from 06/29/2020 15:00:00 to 01/01/2200 00:00:00
Scenario #2:
no appointment possible思路：
首先TA开会的条件是人数大于等于2，并且缺席的人数最多是一个人。由此，一开始理解的是同一个TA的任务不会有重叠的，因此只需考虑两种情况，即人数刚好为2两个人的，这种情况下，有任务的时间都不行，直接考虑空闲的时间，大于两个人的时候，最多只有一个任务在进行，即从反面思考，也不用考虑后面string的部分。然后有一个时间的结构体，并且重写<，在这种情况下应该简单的多。 然后看到群里有人问到了，说是题目没有给这样的信息，就不能这样考虑。然后就思路有点懵，因为得考虑后面的TA了，但是string中又没有明确的TA的名字在哪。在此借鉴了别人的思路，即用了TA_work【】数组分别记录下了每个TA的任务数。然后将开始时间和结束时间分别用一个二维数组记录。如Begin[][]和End[][]。其中第一维记录是哪个TA，第二维记录的是这个TA的任务，其中Begin和End由索引相对应（这里用到了注：（题目中我没有明确看到，但同学们的时候，说是每个人的任务的时间是递增给出来的，这让在判断的时候也带来了方便。）的信息，要不还是挺麻烦）。 然后用的一个总的数组sum[]记录下所有的时间，并进行排序，在这个sum数组中遍历每一个时间点。然后有一个judge函数，即判断在这个时间点的空闲TA的数量，从正面判断，这个时间点是不是符合。在judge函数中，即遍历每一个TA，看这个TA是不是在这个时间点空闲，首先如果TA没有任务为空闲，可以直接返回，然后，TA任务的开始时间如果比这个时间迟，则空闲，返回，如果TA的结束时间比这个时间迟，也空闲。（如果没有哪个条件，则还要遍历一边，得到所有任务的最初开始时间和最后的结束时间）。如果这几个简单的条件不符合，则遍历每一个任务，即前一个任务结束的时间和后一个任务的开始时间，如果在这个空闲的时间里，则空闲。遍历完毕得到在这个时间点的空闲的TA的个数。如果符合题意返回true，否则返回false。利用这个函数从sum函数中因此找到第一个符合的左端点和第一个不符合的右端点，其中的时间便为空闲时间，在判断时间是不是超过一个小时，是的话输出，一开始考虑的年月日时分秒依次判断，后来发现太麻烦了，不如直接全部转化为最小单位。直接减，虽然计算量大了，但简单多了。输出的时候注意每组数据之间有一个空行。主要的难点就是在于如何判断在一个时间点的TA空闲的人数吧，一开始想的是将每件事的起始封装在一起，然后依次取出，一次遍历得到，但就会出现很多要考虑得。没有想到用二维数组，第一维记录TA，然后在每个时间点都去遍历所有得TA得所有任务，来判断这个TA在这个时间得空闲人数，虽然时间复杂度大了很多，但思路就简单多了，如果有给每个TA得任务不会重叠，感觉这个题就要简单多了。
代码：
#include <iostream>
#include <cstdio>
#include <algorithm>
#include <string>
#include <cstring>
#include <cstdlib>
using namespace std;
int T, m; //数据组数和每个TA的任务数
struct Time {
int time[6]; //分别记录年月日时分秒
bool operator<(const Time& r) const {
if (time[0] != r.time[0]) return time[0] < r.time[0];
if (time[1] != r.time[1]) return time[1] < r.time[1];
if (time[2] != r.time[2]) return time[2] < r.time[2];
if (time[3] != r.time[3]) return time[3] < r.time[3];
if (time[4] != r.time[4]) return time[4] < r.time[4];
if (time[5] != r.time[5]) return time[5] < r.time[5];
else return 0;
}
bool operator > (const Time& r)const { return r < *this; }
bool operator <= (const Time& r)const { return !(r < *this); }
};
Time Begin[25][105], End[25][105], sum[4500]; //分别记录每个任务的起始时间，结束时间 所有时间混杂在一起
int tot; //记录每组数据中的时间个数
int TA_work[25]; //记录每个TA的任务数
int freeTA; //记录空闲的TA的数量
bool judge(int tp) { //通过判断这个时间点有多少个TA有空闲时间来判断这个点是否合法
freeTA = 0;
for (int i = 0; i < m; i++) { //遍历每个TA
if (TA_work[i] == 0) {
freeTA++; continue; //没有任务
}
if (sum[tp] < Begin[i][0]) {
freeTA++; continue; //这个时间早于TA任务开始的时间
}
if (End[i][TA_work[i] - 1] <= sum[tp]) { //这个时间大于等于最后任务的时候
freeTA++; continue;
}
for (int j = 0; j < TA_work[i] - 1; j++) {
if (End[i][j] <= sum[tp] && sum[tp] < Begin[i][j + 1]) freeTA++; continue;
}
}
if (freeTA >= 2 && freeTA >= m - 1) return 1;
return 0;
}
void output(int tp) {
if (sum[tp].time[1]< 10) {
cout << 0; //月
}
cout << sum[tp].time[1];
if (sum[tp].time[2] < 10) { //日
cout << "/0" << sum[tp].time[2];
}else {
cout << "/" << sum[tp].time[2];
}
cout << "/" << sum[tp].time[0] << " "; //年
if (sum[tp].time[3] < 10) cout << 0; //时
cout << sum[tp].time[3];
if (sum[tp].time[4] < 10) cout << ":0" << sum[tp].time[4]; //分
else cout << ":" << sum[tp].time[4];
if (sum[tp].time[5] < 10) cout << ":0" << sum[tp].time[5]; //秒
else cout << ":" << sum[tp].time[5];
return;
}
bool judge_time(int l, int r) {
long long time1 = (long long)(sum[r].time[0] - sum[l].time[0]) * 12 * 30 * 24 * 3600 +
(long long)(sum[r].time[1] - sum[l].time[1]) * 30 * 24 * 3600 +
(long long)(sum[r].time[2] - sum[l].time[2]) * 24 * 3600 +
(long long)(sum[r].time[3] - sum[l].time[3]) * 3600 +
(long long)(sum[r].time[4] - sum[l].time[4]) * 60 +
(long long)(sum[r].time[5] - sum[l].time[5]);
if (time1 >= 3600) return 1;
return 0;
}
int main() {
ios::sync_with_stdio(0);
cin >> T;
for (int TT = 0; TT < T; TT++) { //数据组数
cin >> m; //TA数量
memset(Begin, 0, sizeof(Begin));
memset(End, 0, sizeof(End));
memset(sum, 0, sizeof(sum));
tot = 0;
sum[tot].time[0] = 1800, sum[tot].time[1] = 1, sum[tot].time[2] = 1;
sum[tot].time[3] = 0, sum[tot].time[4] = 0, sum[tot].time[5] = 0;
tot++;
sum[tot].time[0] = 2200, sum[tot].time[1] = 1, sum[tot].time[2] = 1;
sum[tot].time[3] = 0, sum[tot].time[4] = 0, sum[tot].time[5] = 0;
tot++;
freeTA = 0;
//以上都为初始化
if(TT!=0) cout<<endl;
for (int mm = 0; mm < m; mm++) { //每个TA的任务数量
cin >> TA_work[mm];
for (int i = 0; i < TA_work[mm]; i++) {
cin >> Begin[mm][i].time[0] >> Begin[mm][i].time[1] >> Begin[mm][i].time[2];
cin >> Begin[mm][i].time[3] >> Begin[mm][i].time[4] >> Begin[mm][i].time[5];
cin >> End[mm][i].time[0] >> End[mm][i].time[1] >> End[mm][i].time[2];
cin >> End[mm][i].time[3] >> End[mm][i].time[4] >> End[mm][i].time[5];
sum[tot] = Begin[mm][i], tot++;
sum[tot] = End[mm][i], tot++;
string s;
getline(cin, s);
}
}
sort(sum, sum + tot); //给sum里面的排序
cout << "Scenario #" << TT+1 << ":" << endl;
int left = 0, right = 0; //记录的是数组的下标
int count = 0; //标记假如没有这样的点
while (left < tot && right < tot) { //其中tot是记录的总的任务数量
while (left < tot && !judge(left)) { //找到第一个合法的左端点
left++;
}
right = left; //右端点从合法的左端点开始
while (right < tot && judge(right)) { //找到第一个不合法的右端点
right++;
}
if (right == tot) right--; //tot记录的任务数，数组下标最多为tot-1
if (judge_time(left, right)) { //超过一小时
cout << "appointment possible from ";
output(left);
cout << " to ";
output(right);
cout << endl;
count++;
}
right++;
left = right; //从下一个点开始
}
if (count == 0) {
cout << "no appointment possible" << endl;
}
}
return 0;
}
扫一扫
961
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
