SDU程序设计思维Week10-限时模拟 B-团队聚会

最新推荐文章于 2022-07-12 00:00:00 发布

Scott Yang

最新推荐文章于 2022-07-12 00:00:00 发布

阅读量446

点赞数

文章标签：程序设计

本文链接：https://blog.csdn.net/weixin_44578615/article/details/105745377

版权

SDU程序设计思维Week10-限时模拟

B-团队聚会

Description

TA团队每周都会有很多任务，有的可以单独完成，有的则需要所有人聚到一起，开过会之后才能去做。但TA团队的每个成员都有各自的事情，找到所有人都有空的时间段并不是一件容易的事情。
给出每位助教的各项事情的时间表，你的任务是找出所有可以用来开会的时间段。

输入格式
第一行一个数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天的，数据保证不含有不合法的日期。
注意每件事务的结束时间点也即是该成员可以开始参与开会的时间点。

输出格式
对于每一组数据，首先输出一行"Scenario #i:"，i即表明是第i组数据。
接下来对于所有可以用来开会的时间段，每一个时间段输出一行。
需要满足如下规则：
    1.在该时间段的任何时间点，都应该有至少两人在场。
    2.在该时间段的任何时间点，至多有一位成员缺席。
    3.该时间段的时间长度至少应该1h。
所有的成员都乐意一天24h进行工作。

举个例子，假如现在TA团队有3位成员，TT、zjm、hrz。
那么这样的时间段是合法的：会议开始之初只有TT和zjm，后来hrz加入了，hrz加入之后TT离开了，此后直到会议结束，hrz和zjm一直在场。

要求：
    1.输出满足条件的所有的时间段，尽管某一段可能有400年那么长。
    2.时间点的格式为MM/DD/YYYY hh:mm:ss。
    3.时间段的输出格式为"appointment possible from T0 to T1"，其中T0和T1均应满足时间点的格式。
    4.严格按照格式进行匹配，如果长度不够则在前面补前导0。
    5.按时间的先后顺序输出各个时间段。
    6.如果没有合适的时间段，输出一行"no appointment possible"。
    7.每组数据末尾须打印额外的一行空行。

Sample

Input：
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

Output:
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

Idea

构建时间类，包含年月日小时分钟秒，实现基本的符号重载
s用于存储每个成员的事务的起始时间，e用于存储每个成员事务的结束时间，t用于存储所有时间点初始包含了时间范围边界点
初始化变量，输入每个成员事务的时间点，直接忽略描述信息
对t中所有时间点升序排序后，从最左侧开始进行与滑动窗口类似的操作确定空闲时间段
首先确定使空闲时间段最长的右边界，要求时间点位于空闲时间，此时间点有空的人数至少2人且最多缺席一人
确定好右边界后，就确定了一段空闲时间段（初始左边界是最左侧，之后每轮的左边界由上一轮确定），判断该时间段是否满足一个小时，满足则输出该时间段。
之后确定下一轮时间段的左边界，方法与确定右边界时类似。
重复之前的操作持续向右滑动窗口
用一个标记记录是否有输出符合要求的空闲时间段，最后如果没有则输出相应信息

Summary

这道题难，有很多细节点要注意，WA了好几次结果是输出上有问题！基本思想是类似滑动窗口的操作，几个难点包括对输入的时间字符串的转化（一开始想把一个时间点的年月日等结合成一个，但在判断时间段是否满足一小时出现了困难）、确定空闲时间段的左右界，对于给定的时间点要确定每个成员在该点的状态，统计在该时间点有空的成员总数，要至少2人且最多缺席一人才算是符合要求的边界。

Codes

#include <iostream>
#include <string>
#include <cstring>
#include <queue>
#include <algorithm>
#include <cstdlib>
#include <cstdio>
using namespace std;

struct time {
	int year, month, day, hour,minute,second;

	time() {}

	time(int y, int mon, int d, int h, int min, int s) {
		year = y, month = mon, day = d, hour = h, minute = min, second = s;
	}
	bool operator < (const time &b)const
	{
		if (year != b.year)return year < b.year;
		if (month != b.month)return month < b.month;
		if (day != b.day)return day < b.day;
		if (hour != b.hour)return hour < b.hour;
		if (minute != b.minute)return minute < b.minute;
		return second < b.second;
	}
	bool operator > (const time &b)const { return b < *this; }
	bool operator <= (const time &b)const { return !(b < *this); }

	bool operator == (const time &b)const { return !(b < *this || *this < b); }



}s[25][120],e[25][120],t[4020];

int T,num[25], cnt, n;
time tbegin(1800, 1, 1, 0, 0, 0), tend(2200, 1, 1, 0, 0, 0);
int flag = 0;

void print(int i) {
	if (t[i].month < 10)printf("0");
	printf("%d/", t[i].month);
	if (t[i].day < 10)printf("0");
	printf("%d/", t[i].day);
	printf("%d ", t[i].year);
	if (t[i].hour < 10)printf("0");
	printf("%d:", t[i].hour);
	if (t[i].minute < 10)printf("0");
	printf("%d:", t[i].minute);
	if (t[i].second < 10)printf("0");
	printf("%d", t[i].second);

}
//确定空闲段的右边界
bool beright(int index) {
	if (index == 0)return 0;
	int tot = 0;
	for (int i = 1; i <= n; i++) {
		if (num[i] == 0) { tot++; continue; }

		if (t[index] <= s[i][1] && t[index] > tbegin) { tot++; continue; }

		if (t[index] > e[i][num[i]]) { tot++; continue; }
		if (t[index] == e[i][num[i]])continue;
		for (int j = 1; j <= num[i]; j++) {
			if (t[index] > s[i][j] && t[index] <= e[i][j])break;
		
			if (j + 1 <= num[i] && t[index] > e[i][j] && t[index] <= s[i][j + 1]) { tot++; break; }
		
		}

	}

	//至少两个人在场以及最多一人缺席
	if (tot >= 2 && tot >= n - 1)return 1;
	else return 0;


}
//确定空闲段的左边界
bool beleft(int index) {
	if (index == cnt)return 0;

	int tot = 0;
	for (int i = 1; i <= n; i++)
	{
		if (num[i] == 0) { tot++; continue; }
		if (t[index] < s[i][1]) { tot++; continue; }

		if (e[i][num[i]] <= t[index] && tend > t[index]) { tot++; continue; }
		for (int j = 1; j <= num[i]; j++) {
			if (s[i][j] <= t[index] && e[i][j]>t[index])break;
			if (j + 1 <= num[i] && e[i][j] <= t[index] && s[i][j + 1] > t[index]) { tot++; break; }

		}

	}
	if (tot>=2 &&tot >= n - 1)return 1;
	else return 0;


}

//满足1h长
bool anhour(int left, int right) {
	time l=t[left], r=t[right];

	if (r.year - l.year >= 2)return 1;
	r.month += (r.year - l.year) * 12;

	if (r.month - l.month >= 2)return 1;
	r.day += (r.month - l.month) * 30;

	if (r.day - l.day >= 2)return 1;
	r.hour += (r.day - l.day) * 24;

	if (r.hour - l.hour >= 2)return 1;
	r.minute += (r.hour - l.hour) * 60;

	r.second += (r.minute - l.minute) * 60;
	if (r.second - l.second >= 3600)return 1;
	return 0;

	
}

void judge(int left, int right) {
	if (!anhour(left, right))return;
	flag = 1;
	printf("appointment possible from ");
	print(left);
	printf(" to ");
	print(right);
	printf("\n");


}




int main() 
{
	cin.sync_with_stdio(false);
	cin >> T;
	for (int cc = 1; cc <= T; cc++) {

		memset(num, 0, sizeof(num));
		memset(s, 0, sizeof(s));
		memset(e, 0, sizeof(e));
		memset(t, 0, sizeof(t));
		cnt = 0;
		flag = 0;
		t[++cnt] = tbegin;
		t[++cnt] = tend;
		cin >> n;
		for (int i = 1; i <= n; i++) {
			cin >> num[i];
			for (int j = 1; j <= num[i]; j++) {
				cin >> s[i][j].year >> s[i][j].month >> s[i][j].day >> s[i][j].hour >> s[i][j].minute >> s[i][j].second;
				cin >> e[i][j].year >> e[i][j].month >> e[i][j].day >> e[i][j].hour >> e[i][j].minute >> e[i][j].second;
				t[++cnt] = s[i][j];
				t[++cnt] = e[i][j];
				string meiyong;
				getline(cin,meiyong);



			}
		}

		sort(t + 1, t + 1 + cnt);

		printf("Scenario #%d:\n", cc);
		int left = 1, right = 1;
		while (left <= cnt && right <= cnt) {
			right++;
			if (right > cnt)break;
			//找到使时间段最长的右边界
			while (right <= cnt && beright(right))right++;
			right--;

			judge(left, right);

			left = right + 1;
			//确定左边界
			while (left <= cnt && !beleft(left))left++;
			right = left;

		}
		if (flag == 0)printf("no appointment possible\n");
		printf("\n");


	}



}