Week14 烦人的小CAT（HDU - 3700 ）

题目概述

众所周知，TT家里有一只魔法喵。这只喵十分嗜睡。一睡就没有白天黑夜。喵喵一天可以睡多次！！每次想睡多久就睡多久╭(╯^╰)╮
喵睡觉的时段是连续的，即一旦喵喵开始睡觉了，就不能被打扰，不然喵会咬人哒[○･｀Д´･ ○]
可以假设喵喵必须要睡眠连续不少于 A 个小时，即一旦喵喵开始睡觉了，至少连续 A 个小时内（即A*60分钟内）不能被打扰！
现在你知道喵喵很嗜睡了，它一天的时长都在吃、喝、拉、撒、睡，换句话说要么睡要么醒着滴！
众所周知，这只魔法喵很懒，和TT一样懒，它不能连续活动超过 B 个小时。
猫主子是不用工作不用写代码滴，十分舒适，所以，它是想睡就睡滴。
但是，现在猫主子有一件感兴趣的事，就是上BiliBili网站看的新番。
新番的播放时间它已经贴在床头啦（每天都用同一张时间表哦），这段时间它必须醒着！！
作为一只喵喵，它认为安排时间是很麻烦的事情，现在请你帮它安排睡觉的时间段。

输入样例

多组数据，多组数据，多组数据哦，每组数据的格式如下：
第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 分钟。
不保证输入的新番时间表有序。
输入样例

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

输出样例

我们知道，时间管理是一项很难的活，所以你可能没有办法安排的那么好，使得这个时间段满足喵喵的要求，即每次睡必须时间连续且不少于 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 不太一样，也可能是对的，它有一个判题程序来判定你的答案（当然，你对你自己的答案肯定也能肉眼判断）
输出样例

Yes
1
01:07-22:13
No

思路简述

这道题真的是很难受和很难受的模拟题，看看大佬对于这道HDU-3700的糟糕评价，就大概了解这道题目的坑之多。下面先来说说坑：
1、这道题目的时间边界是闭区间，也就是说如果7:00-8:00要看剧，看剧时间是61分钟。如果看剧到了7:00，从8:00又要开始新的看剧，那么这中间一共睡了59分钟。这点是刚刚上手时候非常容易掉进的第一个坑
2、如果有一部剧是从第一天的晚上到第二天早上，那么就要考虑到睡觉是考虑一天还是考虑两天的问题。这里有一个比较好的解法，在后续思路简述我们会再做叙述。
3、这道题最大的坑就是，如果输入的允许连续醒着的时间是24小时，那猫猫可以很多天不睡觉么？
一开始思考或许你会简单的认为猫猫可以每天醒24小时，这样一来就可以一直醒着下去。但是注意这里给出的是允许连续醒着的时间。也就是说如果第一天已经醒了24小时，第二天不能够继续醒着，必须休息一段才能够继续醒着。

了解了这三个关键点就可以开始写本题的代码了：
首先：明确我们如何处理延伸到第二天的问题----既然要考虑两天，我们就把它延长为两天。因为考虑到延伸到第二天的情况只会考虑延伸到第二天的第一个时间段（因为如果考虑到第二段其起始时间和结束时间都会是第二天，这种考虑无意义），第二天的第一个时间段的时间计算方式就是在第一天的第一个时间段基础上加上24小时。

其次：我们要考虑如何把时间存放下来。一种比较好比较简便的方式就是只存分钟数，只在输入和输出时进行时分表示形式和纯分钟表示形式的转换。使用这种方式可以大大缓解时分运算时的种种不方便，但是要注意的是，在取两个分钟值 t1\t2 之间时段的时间值时，计算方式应该是：
$$T=t1-t2+1$$

清楚了上面两个关键的处理，就可以开始写代码了。我们按照如下的步骤：
1、合并。如果两个区间之间间隔时间小于最短睡觉时间A，这两个区间就要合并。
2、检查区间是否超时。如果一个合成或者没有合成的区间的总时间超过了最大醒着的时间B，返回一个false
3、检查区间之间能否足够睡觉。如果每两个区间的间隙都保证可以睡至少最短时间A，则证明可以合法的完成，否则无法完成。

实现源码

#include<iostream>
#include<stdio.h>
#include<string>
#include<string.h>
#include<algorithm>
#include<stdlib.h>
#include<vector>
using namespace std;
int make_num(int tenth,int oneth)
{
    
    
    return 10*tenth+oneth;
}
struct timetable
{
    
    
    int begin_minute;//保持开始时间计算不变
    int end_minute;//结尾时间
    timetable()
    {
    
    
        begin_minute=0;
        end_minute=0;
    }
    bool operator<(timetable a)
    {
    
    
        return begin_minute<a.begin_minute;
    }
    void make_minute(int begin_hour,int begin_min,int end_hour,int end_min)
    {
    
    
        begin_minute=begin_hour*60+begin_min;
        if(begin_hour>end_hour)
        {
    
    
            end_minute=(24+end_hour)*60+end_min;
        }
        else
        {
    
       
            end_minute=end_hour*60+end_min;
        }
    }
    int tell_time()
    {
    
    
        return (end_minute-begin_minute+1);
    }
    void output()
    {
    
    
        begin_minute=begin_minute%(24*60);
        end_minute=end_minute%(24*60);
        int out_begin_h=begin_minute/60;
        int out_begin_m=begin_minute%60;
        int out_end_h=end_minute/60;
        int out_end_m=end_minute%60;
        printf("%02d:%02d-%02d:%02d\n",out_begin_h,out_begin_m,out_end_h,out_end_m);
    }
};
timetable list[25];
vector<timetable> vec;

int main()
{
    
    
    int sleep_time=0;
    int work_time=0;
    int datagroup=0;
    bool flag;
    string s;
    while (scanf("%d %d %d",&sleep_time,&work_time,&datagroup)!=EOF)
    {
    
    
        flag=true;
        for(int i=0;i<25;i++)
        {
    
    
            list[i].begin_minute=0;
            list[i].end_minute=0;
        }
        for(int i=0;i<datagroup;i++)
        {
    
    
            int begin_hour;int begin_min;int end_hour;int end_min;
            scanf("%d:%d-%d:%d",&begin_hour,&begin_min,&end_hour,&end_min);
            list[i].make_minute(begin_hour,begin_min,end_hour,end_min);
        }
        if(sleep_time==24)
        flag=false;
        sort(list,list+datagroup);
        sleep_time*=60;
        work_time*=60;
        list[datagroup].begin_minute=list[0].begin_minute+24*60;
        list[datagroup].end_minute=list[0].end_minute+24*60;
        datagroup++;
        for(int i=1;i<datagroup;i++)
        {
    
    
            if((list[i].begin_minute-list[i-1].end_minute-1)<sleep_time)//如果睡觉间隔小于要求就合并
            {
    
    
                list[i-1].end_minute=list[i].end_minute;
                for(int j=i;j<datagroup-1;j++)
                {
    
    
                    list[j].begin_minute=list[j+1].begin_minute;
                    list[j].end_minute=list[j+1].end_minute;
                }
                i--;datagroup--;
            }
        }
        for(int i=0;i<datagroup;i++)
        {
    
    
            if(list[i].tell_time()>work_time)
            {
    
    
                flag=false;
                break;
            }
        }
        vec.clear();
        for(int i=0;i<datagroup-1;i++)
        {
    
    
            if((list[i+1].begin_minute-list[i].end_minute-1)>=sleep_time)
            {
    
    
                timetable a;
                a.begin_minute=list[i].end_minute+1;
                a.end_minute=list[i+1].begin_minute-1;
                vec.push_back(a);
            }
            else
            {
    
    
               flag=false;
               break;   
            }
        }
        if(flag==false)
        {
    
    
            printf("No\n");
        }
        else
        {
    
    
            printf("Yes\n");
            printf("%d\n",vec.size());
            for(int i=0;i<vec.size();i++)
            {
    
    
                vec[i].output();
            }
        }
    }
    return 0;
}