[大模拟]Test Week14 猫睡觉问题

2023-05-16

目录

  • [大模拟]猫睡觉问题
    • 题意
    • 样例
      • 样例输入:
      • 样例输出:
    • 思路
    • 总结
    • 代码

[大模拟]猫睡觉问题

题意

众所周知,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

思路

1.首先分析题意:
有N个时间段 格式为hh:mm-hh:mm 在每两个时间段之间有一个空闲的时间段
要求为 :只有空闲的时间段长度>=A小时 时 才可以休息 且给出的时间段内不能休息 并且当连续不休息的时间超过(>)B小时 时 不满足条件

2.基本思路
①判断每一个空闲时间段的长度,如果长度>=A 则将这个空闲时间段的全部用来睡觉(这样可以尽可能的满足条件) 否则只能累加到不休息的时间中
②利用时间轴模拟一天的时间

3.具体细节
①如何计算连续的空闲时间与连续的不休息时间?
在跑时间轴的过程中
用wake记录连续的不休息的时间 当某一次休息后 置wake=0
用tnt记录连续的空闲时间 当到达一个不空闲的时间段时 判断tnt是否大于等于A*60
②如何处理跨越零点的时间段?
首先从23:59向前遍历(23:58,23:57···) 再从00:00向后遍历 合起来即特殊处理了跨越零点的时间段 然后我们接着上次00:00遍历时停下的时刻 向后模拟时间轴即可


总结

一个蛮复杂的模拟题,虽然看上去好像不太复杂
尤其是B=24时的情况着实让人没有想到
一开始 我的程序会输出 Yes 0
但是仔细考虑会发现 尽管输出了Yes 但是因为休息的时间段的数目为0 故这一天其实还是没有消息 但考虑连续的两天 这两天的不休息时间会连续成48小时>24小时 故在这种情况下其实不满足题目要求 故需要对休息的时间段数目进行判断 如果等于0 则还是不满足条件(TAT)


代码

因为是完全模拟 所以写的比较乱...
#include<iostream>
#include<string.h>
#include<algorithm>
#include<stdio.h>
#include<math.h>
#include<map>
#include<vector>
using namespace std;
int A,B,N;
bool day[50][100];//day[i][j]=1 表示是被占用的

struct Mytime
{
    int hour;
    int minute;
    Mytime () {hour=0;minute=0;}
    Mytime(int h,int m) {hour=h;minute=m;}
    Mytime(string s)
    {//这里写 23:56 ->hour=23 minute=56 将字符串转化
        sscanf(s.c_str(),"%d:%d",&hour,&minute);
    }
    bool operator < (const Mytime &t) const{
        if(hour!=t.hour)    return hour<t.hour;
        else return minute<t.minute;
    }
    bool operator == (const Mytime &t)  const{
        if(hour==t.hour&&minute==t.minute)  return true;
        return false;
    }
};
bool cmp(pair<Mytime,Mytime> p1,pair<Mytime,Mytime> p2)
{
    return p1.first<p2.first;
}
int f(char c1,char c2)
{
    int sum=0;
    sum=(c1-'0')*10+(c2-'0');
    return sum;
}
vector<pair<Mytime,Mytime> > v;
int main()
{
    while(cin>>A>>B>>N)
    {
        memset(day,0,sizeof(day));
        v.clear();
        string s;
        for(int i=1;i<=N;i++)//对数据的处理
        {
            cin>>s;
            int sh=f(s[0],s[1]),sm=f(s[3],s[4]);
            int th=f(s[6],s[7]),tm=f(s[9],s[10]);
            Mytime s(sh,sm),t(th,tm);
            while(true)
            {
                day[s.hour][s.minute]=1;
                s.minute++;
                if(s.minute==60)    {s.minute=0;s.hour++;}
                if(s.hour==24)  s.hour=0;
                if(s==t)    {day[t.hour][t.minute]=1;break;}
            }
        }


        Mytime x;
        int ok=1;
        if(!day[x.hour][x.minute])//00:00时空闲 所以我们要向前 向后找 看一下这段的时间段
        {
            //先从x开始向左右遍历
            int tnt=0,wake=0;
            Mytime cur(23,59),s(0,0),t(0,0);
            while(true)//从0:00向前倒推 等会从前往后时只需到cur即可
            {
                if(day[cur.hour][cur.minute]) break;//当=1时 说明已经不空闲
                tnt++;
                s=cur;
                cur.minute--;
                if(cur.minute==-1)  {cur.minute=59;cur.hour--;}
                if(cur.hour==-1)    break;
            }
            while(true)//从0:00开始
            {
                if(day[x.hour][x.minute])   break;
                tnt++;
                t=x;
                x.minute++;
                if(x.minute==60)    {x.hour++;x.minute=0;}
                if(x.hour==24)  break;
            }
            
            if(tnt>=A*60)//全部用来睡觉
                v.push_back(make_pair(s,t));
            else //不能用于睡觉
            {
                wake=tnt;
                if(wake>B*60)   ok=0;
            }
            //接着从x正序遍历 直到cur
            tnt=0;int Free=0;
            Mytime pre,end;
            while(true)
            {
                //if(x.hour==11&&x.minute==10)
                if(!day[x.hour][x.minute])//表示有空
                {
                    if(Free==0)
                    {
                        Free=1;
                        pre=x;//记录空闲段的起始位置
                    }
                    end=x;//end记录了上一次是空闲的最后时间
                    tnt++;
                }else //没空
                {
                    if(tnt!=0)
                    {   
                        if(tnt>=A*60)//全部用来睡觉
                        { 
                            if(wake>B*60)
                            {
                                ok=0;
                                break;
                            }
                            v.push_back(make_pair(pre,end));
                            wake=0;//这一空闲段用于睡觉了 wake=0
                        }
                        else //不能用于睡觉
                        {
                            wake+=tnt;
                            if(wake>B*60)
                            {
                                ok=0;
                                break;
                            }
                        }
                    }
                    wake++;
                    Free=0;
                    tnt=0;
                }

                x.minute++;
                if(x.minute==60) {x.hour++;x.minute=0;}
                if(x.hour==24)  break;
                if(cur<x)  break;
            }
            
            if(wake>B*60)   ok=0;
        }
        else//没有空闲段是跨0点的 我们只需要从00:00向23:59遍历即可
        {
            int wake=0;
            Mytime cur(23,59);
            while(true)//从0:00向前倒推 等会从前往后时只需到cur即可
            {
                if(!day[cur.hour][cur.minute]) break;//当=0时 说明已经空闲
                wake++;
                cur.minute--;
                if(cur.minute==-1)  {cur.minute=59;cur.hour--;}
                if(cur.hour==-1)    break;
            }
            while(true)//从0:00开始
            {
                if(!day[x.hour][x.minute])   break;
                wake++;
                x.minute++;
                if(x.minute==60)    {x.hour++;x.minute=0;}
                if(x.hour==24)  break;
            }
            //计算完毕了跨0点看番的情况
            if(wake>B*60)   ok=0;
            int Free=0,tnt=0;
            Mytime pre,end;
            while(true)
            {
                //if(x.hour==11&&x.minute==10)
                if(!day[x.hour][x.minute])//表示有空
                {
                    if(Free==0)
                    {
                        Free=1;
                        pre=x;//记录空闲段的起始位置
                    }
                    end=x;//end记录了上一次是空闲的最后时间
                    tnt++;
                }else //没空
                {
                    if(tnt!=0)
                    {   
                        if(tnt>=A*60)//全部用来睡觉
                        { 
                            if(wake>B*60)
                            {
                                ok=0;
                                break;
                            }
                            v.push_back(make_pair(pre,end));
                            wake=0;//这一空闲段用于睡觉了 wake=0
                        }
                        else //不能用于睡觉
                        {
                            wake+=tnt;
                            if(wake>B*60)
                            {
                                ok=0;
                                break;
                            }
                        }
                    }
                    wake++;
                    Free=0;
                    tnt=0;
                }
                x.minute++;
                if(x.minute==60) {x.hour++;x.minute=0;}
                if(x.hour==24)  break;
                if(cur<x)  break;
            }
            if(tnt!=0)
            {   
                if(tnt>=A*60)//全部用来睡觉
                { 
                    if(wake>B*60)
                    {
                        ok=0;
                    }
                    v.push_back(make_pair(pre,end));
                    wake=0;//这一空闲段用于睡觉了 wake=0
                }
                else //不能用于睡觉
                {
                    wake+=tnt;
                    if(wake>B*60)   ok=0;
                }
            }
        }
        if(ok==1)
        {
            if(v.size()==0)
            cout<<"No"<<endl;
            else{
            cout<<"Yes"<<endl;
            cout<<v.size()<<endl;
            sort(v.begin(),v.end(),cmp);
            for(auto &entry:v)
            {
                if(entry.first.hour<10) cout<<"0"<<entry.first.hour<<":";
                else cout<<entry.first.hour<<":";

                if(entry.first.minute<10)   cout<<"0"<<entry.first.minute<<"-";
                else cout<<entry.first.minute<<"-";

                if(entry.second.hour<10)    cout<<"0"<<entry.second.hour<<":";
                else cout<<entry.second.hour<<":";

                if(entry.second.minute<10)  cout<<"0"<<entry.second.minute<<endl;
                else cout<<entry.second.minute<<endl;
            }
            
            }
        }
        else if(ok==0)  cout<<"No"<<endl;
    }

    system("pause");
    return 0;
}
本文内容由网友自发贡献,版权归原作者所有,本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容,请联系:hwhale#tublm.com(使用前将#替换为@)

[大模拟]Test Week14 猫睡觉问题 的相关文章

  • 哈夫曼树

    什么是哈夫曼树 xff1f 让我们先举一个例子 判定树 xff1a 在很多问题的处理过程中 xff0c 需要进行大量的条件判断 xff0c 这些判断结构的设计直接影响着程序的执行效率 例如 xff0c 编制一个程序 xff0c 将百分制转换
  • 哈夫曼树的概念及其实现

    1 基本概念 a 路径和路径长度 若在一棵树中存在着一个结点序列 k1 xff0c k2 xff0c xff0c kj xff0c 使得 ki是ki 43 1 的双亲 xff08 1 lt 61 i lt j xff09 xff0c 则称此
  • 二叉排序树详解

    二叉排序树的介绍 二叉排序树为一颗二叉树 xff0c 或者为空 xff0c 或者满足如下条件 xff1a 如果它的左子树不为空 xff0c 那么左子树上的所有结点的值均小于它的根结点的值如果它的右子树不为空 xff0c 那么右子树上的左右结
  • 数据结构实验之队列一:排队买饭

    数据结构实验之队列一 排队买饭 这个题猛的一看可能会有点麻烦 xff0c 但是其实一点也不 xff0c 只要把每个情况用if条件语句分清就可以了 有一点栈的思想 Problem Description 中午买饭的人特多 食堂真是太拥挤了 买
  • bLue的文件查找器

    bLue的文件查找器 用结构体数组按顺序存储 xff0c 每次查找的时候只是判断最后的文件格式ex Problem Description bLue 的电脑里存了各种各样的文件 xff0c 随着文件越来越多 xff0c 查找文件也成了一个麻
  • 图的基本存储的基本方式二

    小编在网上看到好多博主的文章这道题都没有用结构体做 xff0c 数据量太大 xff0c 结构体也是一个不错的选择 但是结构体有一个不好的地方 xff0c 不能直接搜索 xff0c 只能每次从头开始搜索 xff0c 有点浪费时间 Proble
  • 图的基本存储的基本方式一

    这个题主要的是这个 stdbool h 这个函数 xff0c 还有bool这个数组 Problem Description 解决图论问题 xff0c 首先就要思考用什么样的方式存储图 但是小鑫却怎么也弄不明白如何存图才能有利于解决问题 你能
  • 图的基本存储的基本方式四

    一直不知道这个题为什么用链表可以A xff0c 但是结构体就会WA xff0c 如果有童鞋们知道 xff0c 希望能留下想法 xff0c 一起学习 xff0c 一起进步 Problem Description 解决图论问题 xff0c 首先
  • C# 超详细的WebService创建、发布与调用(VS2019)

    1 编写接口 这里我选择的是 ASP NET Web应用程序 NET Framework 填写好项目名称 选择项目位置以及所使用的框架 xff0c 这里我用的是 NET Framework 4 框架 xff0c 然后点击创建 继续点击创建
  • 图的基本存储的基本方式三

    图的基本存储的基本方式三 Problem Description 解决图论问题 xff0c 首先就要思考用什么样的方式存储图 但是小鑫却怎么也弄不明白如何存图才能有利于解决问题 你能帮他解决这个问题么 xff1f Input 多组输入 xf
  • 数据结构实验之栈与队列九:行编辑器

    数据结构实验之栈与队列九 xff1a 行编辑器 Problem Description 一个简单的行编辑程序的功能是 xff1a 接受用户从终端输入的程序或数据 xff0c 并存入用户的数据区 由于用户在终端上进行输入时 xff0c 不能保
  • 顺序表应用2:多余元素删除之建表算法

    顺序表应用2 xff1a 多余元素删除之建表算法 Time Limit 3 ms Memory Limit 600 KiB Submit Statistic Problem Description 一个长度不超过10000数据的顺序表 xf
  • 数据结构实验之链表四:有序链表的归并

    数据结构实验之链表四 xff1a 有序链表的归并 Problem Description 分别输入两个有序的整数序列 xff08 分别包含M和N个数据 xff09 xff0c 建立两个有序的单链表 xff0c 将这两个有序单链表合并成为一个
  • 数据结构实验之链表五:单链表的拆分

    数据结构实验之链表五 xff1a 单链表的拆分 Problem Description 输入N个整数顺序建立一个单链表 xff0c 将该单链表拆分成两个子链表 xff0c 第一个子链表存放了所有的偶数 xff0c 第二个子链表存放了所有的奇
  • 数据结构——二叉树的基本操作(不包括还原)

    小编没有写主函数 xff0c 你们需要用什么函数只需要自己写一个主函数调用一下就可以了 include lt stdio h gt include lt string h gt include lt stdlib h gt typedef
  • 数据结构实验之图论四:迷宫探索

    数据结构实验之图论四 xff1a 迷宫探索 Time Limit 1000 ms Memory Limit 65536 KiB Problem Description 有一个地下迷宫 xff0c 它的通道都是直的 xff0c 而通道所有交叉
  • 数据结构实验之图论七:驴友计划

    数据结构实验之图论七 xff1a 驴友计划 Time Limit 1000MS Memory Limit 65536KB Problem Description 做为一个资深驴友 xff0c 小新有一张珍藏的自驾游线路图 xff0c 图上详
  • 数据结构实验之排序一:一趟快排

    H 数据结构实验之排序一 xff1a 一趟快排 Problem Description 给定N个长整型范围内的整数 xff0c 要求输出以给定数据中第一个数为枢轴进行一趟快速排序之后的结果 Input 连续输入多组数据 xff0c 每组输入
  • 数据结构实验之排序二:交换排序

    include lt stdio h gt int s x void qsort int a int l int h int i 61 l j 61 h k 61 a l while i gt 61 j return while i lt
  • vs当前不会命中断点,还未为文档加载符号

    一般网上的解决办法是 xff1a A 工具 选项 调试 常规中的 要求源文件和原始版本完全匹配 的勾去掉 B 工具 选项 调试 常规中的 启用仅我的代码 的勾去掉 这种是治标不治本 xff0c 有的时候也不起作用 当前不会命中断点 xff0

随机推荐

  • 数据结构实验之排序三:bucket sort

    数据结构实验之排序三 xff1a bucket sort 作为桶排序的典型例题 xff0c 我们完全可以按照桶排序的思想来做这个题 但是本题完全不需要用太多的空间去换时间 xff0c 只需要一个空间为101的一维数组就好 Problem D
  • 数据结构实训——停车场系统

    这个程序是利用栈和循环队列实现的 xff0c 自己得先处理好逻辑关系就好了 由于题目没有要求 xff0c 这个程序就没加重复判断 xff0c 比如一辆车已经停在车位上或者便道上 xff0c 再来一辆就判断不了了 关于栈 xff0c 就是先进
  • 关于在linux下监测内存泄漏的问题

    小伙伴们 xff0c 会不会时常注意自己的程序会不会有内存泄漏的问题 xff1f 分享一个工具 1 安装valgrind 1 xff09 将安装包valgrind 3 8 1 9 el6 i686 rpm拷贝到虚拟中 2 xff09 yum
  • 计算机组成原理第二章测试题

    1 在定点机中执行算术运算时会产生溢出 xff0c 其原因是 C A 运算过程中最高位产生了进位或借位 B 参与运算的操作数超出了机器的表示范围 C 运算结果的操作数超出了机器的表示范围 D 寄存器的位数太少 2 某机器字长32位 xff0
  • MySQL操作语言汇总

    创建表数据 create table 表名 字段名 数据类型 约束条件 xff0c xff1b xff08 其中约束条件可选 xff09 注意 xff1a 1 必须给定表名 xff0c 且不能使用SQL语言中的关键字 2 必须给字段命名 x
  • 数据库第三次实验

    lt 实验要求 gt 每次实验前学生必须根据实验内容认真准备 在指导教师的帮助下能够完成实验内容 实验结束后总结实验内容 书写实验报告 遵守实验室规章制度 不缺席 实验学时内必须做数据库的有关内容 xff0c 不允许上网聊天或玩游戏 lt
  • 数据库第二次实验

    lt 实验要求 gt 每次实验前学生必须根据实验内容认真准备 在指导教师的帮助下能够完成实验内容 实验结束后总结实验内容 书写实验报告 遵守实验室规章制度 不缺席 实验学时内必须做数据库的有关内容 xff0c 不允许上网聊天或玩游戏 lt
  • 数据库第一次实验

    实验题目 xff1a 认识 DBMS xff08 Oracle xff09 xff0c SQL 数据定义功能实验目的 xff1a 理解数据库模式的概念 xff0c 通过使用 Oracle 的客户端 Oracle OraClient10g h
  • orcl的Windows下的配置

    理解数据库模式的概念 xff0c 通过使用 Oracle 的客户端 Oracle OraClient10g home1 Enterprise Manager Console 建立基本表 xff0c 实现模式对象与用户名之间的关联 熟悉 En
  • 数据库在线测试

  • WSL修改默认安装目录到其他盘eg d:

    1 查看WSL分发版本 在Windows PowerShell中输入如下命令 wsl l all v NAME STATE VERSION Ubuntu 18 04 Running 2 docker desktop Running 2 do
  • iOS 简单的贝塞尔(UIBezierPath)曲线使用

    在iOS中绘制矢量图或者路径的时候通常会用到 UIBezierPath xff0c 它在 UIKit 中 xff0c 是CoreGraphics对path的封装 使用 UIBezierPath xff0c 可以绘制直线 椭圆 多边形和贝塞尔
  • OpenStack计费服务Cloudkitty分析 计费核心(二)

    计费模型是实现计费的核心 xff0c 一般能允许用户根据实际需求设定计费规则并且根据收集到资源数据进行准确的费用计算 Cloudkitty实现了多种计费模型noop xff0c hashmap和pyscripts xff0c 允许同时启动多
  • 跳表的动态演示

    跳表的动态演示 插入操作 删除操作 xff1a 查询操作 xff1a
  • [模拟/模拟/有技巧的搜索] csp第一次模拟

    目录 题目一 咕咕东的奇遇题意样例思路总结代码 题目二 咕咕东想吃饭题意样例思路总结代码 题目三 可怕的宇宙射线题意样例思路总结代码 题目一 咕咕东的奇遇 题意 有一个如图所示的圆环 xff0c 初始时指针指在a处 给定一个字符串 xff0
  • [单调栈/差分/尺取/单调队列]Exercise Week5 A最大矩形+B魔法猫+C平衡字符串+D滑动窗口

    目录 A 单调栈 最大矩形题意样例思路总结代码 B 差分 TT 39 s Magic Cat题意样例思路总结代码 C 尺取 平衡字符串题意样例思路总结代码 D 单调队列 滑动窗口题意样例思路总结代码 A 单调栈 最大矩形 题意 给一个直方图
  • [树的直径/并查集/最小生成树/最小瓶颈生成树]Exercise Week6 A+B+C+D

    目录 A 树的直径 氪金带东题意样例思路总结代码 B 并查集 戴好口罩 xff01 题意样例思路总结代码 C 最小生成树 掌握魔法 东东题意样例思路总结代码 D 最小瓶颈生成树 数据中心题意样例思路总结代码 A 树的直径 氪金带东 题意 实
  • [差分约束/拓扑排序/kosaraju缩点]Exercise Week8 A+B+C

    目录 A 差分约束 区间选点 题意样例样例输入 xff1a 样例输出 思路总结代码 B 拓扑排序 猫猫向前冲题意样例样例输入 xff1a 样例输出 xff1a 思路总结代码 C SCC缩点 区间选点 题意样例样例输入 xff1a 样例输出
  • [大模拟]Test Week8 二阶魔方

    目录 大模拟 东东玩二阶魔方题意d样例样例输入 xff1a 样例输出 思路总结代码 B 模拟 ST串题意样例样例输入 xff1a 样例输出 xff1a 思路总结代码 大模拟 东东玩二阶魔方 题意d 东东有一个二阶魔方 xff0c 即2 2
  • [大模拟]Test Week14 猫睡觉问题

    目录 大模拟 猫睡觉问题题意样例样例输入 xff1a 样例输出 思路总结代码 大模拟 猫睡觉问题 题意 众所周知 xff0c TT家里有一只魔法喵 这只喵十分嗜睡 一睡就没有白天黑夜 喵喵一天可以睡多次 xff01 xff01 每次想睡多久