程序设计思维与实践 Week14 限时大模拟

A - 猫睡觉问题

众所周知，TT家里有一只魔法喵。这只喵十分嗜睡。一睡就没有白天黑夜。喵喵一天可以睡多次！！每次想睡多久就睡多久╭(╯^╰)╮

喵睡觉的时段是连续的，即一旦喵喵开始睡觉了，就不能被打扰，不然喵会咬人哒[○･｀Д´･ ○]

可以假设喵喵必须要睡眠连续不少于 A 个小时，即一旦喵喵开始睡觉了，至少连续 A 个小时内（即A*60分钟内）不能被打扰！

现在你知道喵喵很嗜睡了，它一天的时长都在吃、喝、拉、撒、睡，换句话说要么睡要么醒着滴！

众所周知，这只魔法喵很懒，和TT一样懒，它不能连续活动超过 B 个小时。

猫主子是不用工作不用写代码滴，十分舒适，所以，它是想睡就睡滴。

但是，现在猫主子有一件感兴趣的事，就是上BiliBili网站看的新番。

新番的播放时间它已经贴在床头啦（每天都用同一张时间表哦），这段时间它必须醒着！！

作为一只喵喵，它认为安排时间是很麻烦的事情，现在请你帮它安排睡觉的时间段。

Input

多组数据，多组数据，多组数据哦，每组数据的格式如下：

第1行输入三个整数，A 和 B 和 N (1 <= A <= 24, 1 <= B <= 24, 1 <= n <= 20)

第2到N+1行为每日的新番时间表，每行一个时间段，格式形如 hh:mm-hh:mm (闭区间)，这是一种时间格式，hh:mm 的范围为 00:00 到 23:59。注意一下，时间段是保证不重叠的，但是可能出现跨夜的新番，即新番的开始时间点大于结束时间点。
保证每个时间段的开始时间点和结束时间点不一样，即不可能出现类似 08:00-08:00 这种的时间段。时长的计算由于是闭区间所以也是有点坑的，比如 12:00-13:59 的时长就是 120 分钟。
不保证输入的新番时间表有序。

Output

我们知道，时间管理是一项很难的活，所以你可能没有办法安排的那么好，使得这个时间段满足喵喵的要求，即每次睡必须时间连续且不少于 A 小时，每次醒必须时间连续且不大于 B 小时，还要能看完所有的番，所以输出的第一行是 Yes 或者 No，代表是否存在满足猫猫要求的时间管理办法。

然后，对于时间管理，你只要告诉喵喵，它什么时候睡觉即可。
即第2行输出一个整数 k，代表当天有多少个时间段要睡觉
接下来 k 行是喵喵的睡觉时间段，每行一个时间段，格式形如 hh:mm-hh:mm (闭区间)，这个在前面也有定义。注意一下，如果喵喵的睡眠时段跨越当天到达了明天，比如从23点50分睡到0点40分，那就输出23:50-00:40，如果从今晚23:50睡到明天早上7:30，那就输出23:50-07:30。

输出要排序吗？（输出打乱是能过的，也就是说，题目对输出的那些时间段间的顺序是没有要求的）

哦对了，喵喵告诉你说，本题是 Special Judge，如果你的输出答案和 Sample 不太一样，也可能是对的，它有一个判题程序来判定你的答案（当然，你对你自己的答案肯定也能肉眼判断）

Sample Input

12 12 1
23:00-01:00
3 4 3
07:00-08:00
11:00-11:09
19:00-19:59

Sample Output

Yes
1
01:07-22:13
No

你尝试给喵喵喂小鱼干，它告诉了你一个秘密：“媌，吧唧吧唧小鱼…吧唧吧唧干香吧唧吧唧，媌，这题最麻烦吧唧吧唧…的吧唧吧唧是最后一个番到第二天第一个番期间时间段的处理哦，媌，但是吧唧吧唧可以有一种方法可以很容易处理吧唧吧唧吧唧。啊呀，我要去睡觉啦，媌”

思路

将一天的时间都转化为分钟制，如果一个时间段的开始分钟>结束的分钟，说明它跨越了一天，将结束的分钟+一天的分钟。
将所有时间段按照开始的时间进行排序后，判断猫猫醒着的时间是否有超过b的，如果有，则不满足需求。
如果没有，判断两个看番时间的间隔是否满足猫猫睡觉的条件，满足就加入vector中；不满足，判断该间隔时间+上一个看番时间(为猫猫醒着的时间)是否大于b，大于则不满足需求。
如果这些间隔都满足条件，特别判断一下今天第一个时间段的开始，和昨天最后一个时间段的结束之间的时间间隔是否满足条件。
最后输出结果即可。

反思

最开始我是没有把所有的时间都转换成分钟，只是把小时和分钟分开，在计算时间间隔的时候用的分钟。也是每次判断看番醒着的时间是否>b，还有就是两个番之间的间隔是否<a，但是可能是因为转换什么的问题一直出错WA。
在借鉴了同学的全部转换成分钟的思路后，才AC了。

• 之前的错误代码：

#include <iostream>
#include <algorithm>
#include <vector>
#include<stdio.h>
using namespace std;
//转换时间
void change(int& minute, int& hours)
{
	if (minute % 10 == 9)
	{
		if (minute == 59)
		{
			minute = 0;
			hours += 1;
		}
		else
		{
			minute += 1;
		}
	}
}

//逆转换结束时间
void nchange(int& hours, int& minute)
{
	if (minute%10 == 0)
	{
		if (minute == 0)
		{
			if (hours != 0)
			{
				minute = 59;
				hours -= 1;
			}
		}
		else
		{
			minute -= 1;
		}
	}
}


//计算时间段长度
int gettime(int &beginhours,int &beginminute,int &eddhours, int &eddminute)
{
	int lengthtime = 0;
	int flag = 0;
	change(beginminute, beginhours);
	change(eddminute, eddhours);
	if (beginhours <= eddhours)
	{
		lengthtime += eddminute - beginminute;
		if (lengthtime < 0)
		{
			lengthtime += 60;
			flag = 1;
		}

		if (flag == 0)
		{
			lengthtime += (eddhours - beginhours) * 60;
		}
		else
		{
			lengthtime += (eddhours - 1 - beginhours) * 60;
		}
	}
	else
	{
		lengthtime += 0 - beginminute;
		if (lengthtime < 0)
		{
			lengthtime += 60;
			flag = 1;
		}

		if (flag == 0)
		{
			lengthtime += (24 - beginhours) * 60;
		}
		else
		{
			lengthtime += (23 - beginhours) * 60;

		}

		lengthtime += eddminute;
		lengthtime += eddhours * 60;
	}

	return lengthtime;
}

struct TIME
{
	int beginhours;
	int beginminute;
	int eddhours;
	int eddminute;
	int lengthtime;

	TIME()
	{
		beginhours = beginminute = eddhours = eddminute = lengthtime = 0;
	}

	void getlengthtime()
	{
		lengthtime = gettime(beginhours, beginminute, eddhours, eddminute);
	}

};

TIME ttime[25];
TIME sleeptime[25];
int A, B, N;

bool cmp(TIME& a, TIME& b)
{
	if (a.beginhours != b.beginhours)return a.beginhours < b.beginhours;
	return a.beginminute < b.beginminute;
}

int main()
{
	
	while (cin >> A >> B >> N)
	{
		A = A * 60;
		B = B * 60;
		int x = 0, sleep = 0;
		for (int i = 1; i <= N; i++)
		{
			char temp;
			cin >> ttime[i].beginhours >> temp >> ttime[i].beginminute >> temp >> ttime[i].eddhours >> temp >> ttime[i].eddminute;
		}
		sort(ttime + 1, ttime + N + 1, cmp);
		
		ttime[0].beginhours = ttime[N].beginhours;
		ttime[0].beginminute = ttime[N].beginminute;
		ttime[0].eddhours = ttime[N].eddhours;
		ttime[0].eddminute = ttime[N].eddminute;
		
		
		int j = 0;
		int ff = 0;
		for (int i = 1; i <= N; i++)
		{
			ttime[i].getlengthtime();
			x += ttime[i].lengthtime;
			if (i == 1)
			{
				int temp = 0;
				temp = gettime(ttime[i - 1].eddhours, ttime[i - 1].eddminute, ttime[i].beginhours, ttime[i].beginminute);
				if (temp <= A)
				{
					x += temp;
					ttime[0].lengthtime = x;
				}
				else
				{
					//x = 0;
					sleeptime[j].beginhours = ttime[i-1].eddhours;
					sleeptime[j].beginminute = ttime[i-1].eddminute;
					sleeptime[j].eddhours = ttime[i].beginhours;
					sleeptime[j++].eddminute = ttime[i].beginminute;
				}
			}
			else if (i == N)
			{
				int temp = 0;
				temp = gettime(ttime[i-1].eddhours, ttime[i-1].eddminute, ttime[i].beginhours, ttime[i].beginminute);
				if (temp <= A)
				{
					x += temp;
				}
				else
				{
					//x = 0;
					sleeptime[j].beginhours = ttime[i-1].eddhours;
					sleeptime[j].beginminute = ttime[i-1].eddminute;
					sleeptime[j].eddhours = ttime[i].beginhours;
					sleeptime[j++].eddminute = ttime[i].beginminute;
				}
				x += ttime[0].lengthtime;
			}
			else
			{
				int temp = 0;
				temp = gettime(ttime[i-1].eddhours, ttime[i-1].eddminute, ttime[i].beginhours, ttime[i].beginminute);
				if (temp <= A)
				{
					x += temp;
				}
				else
				{
					x = 0;
					sleeptime[j].beginhours = ttime[i-1].eddhours;
					sleeptime[j].beginminute = ttime[i-1].eddminute;
					sleeptime[j].eddhours = ttime[i].beginhours;
					sleeptime[j++].eddminute = ttime[i].beginminute;
				}
			}

			if (x >= B)
			{
				cout << "NO" << endl;
				x = 0;
				ff = 1;
				break;
			}
			
		}
		
		if (ff == 0)
		{
			cout << "YES" << endl;
			cout << j << endl;
			for (int i = 0; i < j; i++)
			{
				change(sleeptime[i].beginhours, sleeptime[i].beginminute);
				nchange(sleeptime[i].eddhours, sleeptime[i].eddminute);
				printf("%02d:%02d-%02d:%02d\n", sleeptime[i].beginhours, sleeptime[i].beginminute, sleeptime[i].eddhours, sleeptime[i].eddminute);
				//cout << sleeptime[i].beginhours << ":" << sleeptime[i].beginminute << "-" << sleeptime[i].eddhours << ":" << sleeptime[i].eddminute << endl;
			}

		}
		
	}
}

代码

#include <iostream>
#include <algorithm>
#include <vector>
#include<stdio.h>
using namespace std;

const int day = 24 * 60;

struct TIME
{
	int s;
	int e;
};

TIME ti[25];
vector<TIME>vec;
bool cmp(const TIME& a, const TIME& b)
{
	return a.s < b.s;
}


int main()
{
	int a, b, n;
	char str[20];
	
	while (scanf("%d %d", &a, &b) != EOF)
	{
		a *= 60;
		b *= 60;
		scanf("%d", &n);
		for (int i = 1; i <= n; i++)
		{
			scanf("%s", str);
			ti[i].s = (str[0] - '0') * 600 + (str[1] - '0') * 60 + (str[3] - '0') * 10 + (str[4] - '0');
			ti[i].e = (str[6] - '0') * 600 + (str[7] - '0') * 60 + (str[9] - '0') * 10 + (str[10] - '0');
			if (ti[i].e < ti[i].s) 
			{
				ti[i].e += day;
			}
		}
		sort(ti + 1, ti + n + 1, cmp);
		vec.clear();
		bool flag = false;
		for (int i = 1; i <= n; i++)
		{
			if (ti[i].e - ti[i].s + 1 > b)
			{
				flag = true;
				break;
			}
		}
		TIME temp, x;
		if (!flag)
		{
			temp.s = ti[1].s;
			temp.e = ti[1].e;
			for (int i = 1; i < n; i++)
			{
				if (ti[i + 1].s - 1 - temp.e >= a)
				{
					x.s = temp.e + 1;
					x.e = ti[i + 1].s - 1;
					if (x.s != x.e) vec.push_back(x);
					temp.s = ti[i + 1].s;
					temp.e = ti[i + 1].e;
				}
				else
				{
					temp.e = ti[i + 1].e;
					if (temp.e - temp.s + 1 > b)
					{
						flag = true;
						break;
					}
				}
			}
		}

		if (!flag)
		{
			if (ti[1].s + day - 1 - temp.e >= a)
			{
				x.s = (temp.e + 1) % day;
				x.e = (ti[1].s - 1 + day) % day;
				if (x.s != x.e) vec.push_back(x);
			}
			else if (vec.size() > 0 && (vec[1].s - 1 + day) % day - temp.s + 1 <= b)
			{

			}
			else flag = true;
		}

		if (flag || vec.size() == 0)
		{
			printf("No\n");
		}
		else
		{
			printf("Yes\n%d\n", vec.size());
			sort(vec.begin(), vec.end(), cmp);
			for (int i = 0; i < vec.size(); i++)
			{
				printf("%d%d:%d%d-%d%d:%d%d\n", vec[i].s / 600, vec[i].s / 60 % 10, vec[i].s % 60 / 10, vec[i].s % 10, vec[i].e / 600, vec[i].e / 60 % 10, vec[i].e % 60 / 10, vec[i].e % 10);
			}				
		}
	}
}