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
#下面是自己写的几个测试数据
4 10 5
02:17-03:05
08:18-09:12
14:15-16:02
19:52-22:40
23:15-01:59
4 6 4
02:00-03:00
20:00-21:00
21:01-22:03
22:30-01:00
4 8 4
02:00-03:00
20:00-21:00
21:01-22:03
22:30-01:00
4 6 4
02:00-03:00
04:00-06:00
07:00-09:00
11:00-12:00
4 6 4
02:00-03:00
04:00-06:00
07:00-08:00
12:01-12:05
23 23 1
08:00-08:59

Sample Output

Yes
1
01:07-22:13
No
#自己写的测试数据输出
No
Yes
1
03:01-19:59
Yes
1
03:01-19:59
No
No
Yes
1
09:00-07:59

 

题目分析：

• 首先要明确该题的两个硬性要求，连续醒着的时间不能超过B小时，连续睡着的时间不能小于A小时。
• 其次，因为每天的番剧时间表是一样的，那就说明时间是以一天为周期重复的，而每一天的最后时间段可能会影响第二天的第一个时间段，所以需要将时间段以起始时间排序，并且首尾相连。
• 首先scanf输入并存储看番的各时间段，并计算每个时间段的长度，如果长度大于B小时，说明醒着的时间超过了B小时，不可取，输出No。（在这里注意跨夜的时间段和不跨夜的时间段计算方式是不一样的，跨夜的需要按前一天的时间区加上第二天的时间区，不跨夜的直接相减计算即可）
• 然后对看番的时间进行排序，构成一条时间轴，计算每两个时间段的间隔，也即空闲的时间段，如果空闲的时间段长度不小于A小时，说明这段时间可以用来睡觉，那么存入睡觉数组b，并且睡觉区段k1++。如果空闲时间段长度不足以睡觉，那么就必须醒着，也即在连续醒着看番时间和空闲时间，更新计算连续醒着的时间，如果超过B小时，不可取，输出No，如果不超过B小时，则可以继续判断下一个时间区间。（在这里注意睡觉和醒着的时间都是连续的，一个时间要不睡觉要不醒着）
• 最后的首尾交接处，因为存在是否跨夜的问题，所以可以单独拿出来判断，如果跨夜，那么就说明中间的空闲区段在同一天，直接计算即可，如果不跨夜，那么说明中间的空间区段在两天，需要在计算的区间长度加上24*60。其他的判断同其他区间。（在这里注意不管是否跨夜，首尾交接的两个区间的两端一定不在同一天，即第一天的最后一个时间段的开始和第二天的第一个时间段的结束是一定在两天的，（因为之前根据时间排过序了），所以计算连续醒着的时间的时候要减去24*60）
• 最后输出答案时间段的时候，因为时间的进制与一般的数学进制不一样，所以对于端点需要特别处理，59需要进位，小时位加1，分钟为变为0，退位的时候反过来，0退位小时位减1，分钟位变为59，尤其注意23:59和00:00的转换）

WA坑点：

• 输出是Yes和No！！！！（没有想到最后WA这么久是卡在这了，日常眼瞎）
• 因为时间是闭区间，所以对于每个时间段的cnt的计算需要加1，同理，对于睡觉的时间段需要相应的减1。
• 对于B=24的情况，那一天都是醒着的话，就不存在睡觉的时间，这不符合常理，题目隐含条件这个时候输出Yes 0是不对的，而是直接判断No。
• 需要特别注意最后首尾交界处是否跨夜的判断，和相应的加减一天的处理！！

代码：

#include<iostream>
#include<stdio.h>
#include<string.h>
#include<algorithm> 
using namespace std;
struct time
{
	int h1;
	int m1;
	int h2;
	int m2;
	int cnt;
	bool operator<(const time & p)const
	{
		if(h1!=p.h1)
		{
			return h1<p.h1; 
		} 
		else
		{
			return m1<p.m1;
		}
	}

}a[48],b[48];//a记录番剧时间 b记录睡眠时间 

int main()
{
	int A,B,N;
	while(scanf("%d%d%d",&A,&B,&N)!=EOF)
	{
		int k=0;
		int k1=0; 
		char c1,c2,c3;
		int h1,m1,h2,m2;
		bool flag=true;
		bool kuaye=false;
		bool ok=true;
		 
		memset(a,0,sizeof(a));
		memset(b,0,sizeof(b)); 
		
		time pre;
		
		for(int i=0;i<N;i++)
		{
			scanf("%d:%d-%d:%d",&h1,&m1,&h2,&m2);
			a[k].h1=h1;a[k].m1=m1;
			a[k].h2=h2;a[k].m2=m2;
			
			if((a[k].h2<a[k].h1) || (a[k].h1==a[k].h2 && a[k].m2<a[k].m1) )//跨夜 
			{
				a[k].cnt=(23-a[k].h1)*60+(59-a[k].m1)+(a[k].h2*60+a[k].m2)+1+1;
				kuaye=true;
			}
			else //不跨夜 
			{
				a[k].cnt=(a[k].h2-a[k].h1)*60+(a[k].m2-a[k].m1)+1;
			}
			if(a[k].cnt>B*60)//醒着看番时间超过B 
			{
				flag=false;
			}
			k++;	
		}
	
		sort(a,a+k); 
		
		pre.h1=a[0].h1;pre.m1=a[0].m1;
		pre.h2=a[0].h2;pre.m2=a[0].m2;
		pre.cnt=a[0].cnt;
		
		for(int i=1;i<k;i++)//间歇时段 
		{
			int temp=(a[i].h1-a[i-1].h2)*60+(a[i].m1-a[i-1].m2)-1;
			if(temp>=A*60) //间歇时间大于等于A 睡觉 
			{	
				k1++;//睡觉时段加1
				b[k1].h1=a[i-1].h2; b[k1].m1=a[i-1].m2;
				b[k1].h2=a[i].h1; b[k1].m2=a[i].m1;
				pre=a[i];
			}
			else//不能睡觉就得连续醒着 
			{
				int temp1=temp+a[i].cnt;
				pre.cnt+=temp1;
				pre.h2=a[i].h2;pre.m2=a[i].m2;
				if(pre.cnt>B*60)
				{
					flag=false;
					break; 
			}
				
			}	
		}
		if(!flag)
		{
			cout<<"No"<<endl;
			continue; 
		}
		int temp=0;
		if(kuaye)
		{
			temp=(a[0].h1*60+a[0].m1)-(pre.h2*60+pre.m2)-1;
		}
		else
		{
			temp=(a[0].h1*60+a[0].m1)+24*60-(pre.h2*60+pre.m2)-1;
		}
		if(temp>=A*60)//间歇时间大于等于A 睡觉
		{
			k1++;//睡觉时段加1
			b[k1].h1=a[k-1].h2; b[k1].m1=a[k-1].m2;
			b[k1].h2=a[0].h1; b[k1].m2=a[0].m1;
		}
		else//不能睡觉就得连续醒着 
		{
			int temp1=temp+a[0].cnt;
			pre.cnt+=temp1;
			if(k1==0||pre.cnt-24*60>B*60)
			{
				ok=false; 
			}	
		} 
		if(!ok)
		{
			cout<<"No"<<endl;
		}
		else
		{
			cout<<"Yes"<<endl;
			cout<<k1<<endl;
			for(int i=1;i<=k1;i++)
			{
				if(b[i].m1==59)//进位 
				{
					if(b[i].h1==23)
					{
						b[i].h1=0;b[i].m1=0;
					}
					else
					{
						b[i].h1++;b[i].m1=0;
					}	
				}
				else
				{
					b[i].m1++;	
				} 
				if(b[i].m2==0)//退位 
				{
					if(b[i].h2==0)
					{
						b[i].h2=23;b[i].m2=59;
					}
					else
					{
						b[i].h2--;b[i].m2=59;
					}	
				}
				else
				{
					b[i].m2--;
				}
				printf("%02d:%02d-%02d:%02d\n",b[i].h1,b[i].m1,b[i].h2,b[i].m2); 
			}
		}
	}
	return 0;
}