SDU_week10_B - 团队聚会(getline()读入大模拟+时间调度)

最新推荐文章于 2024-05-26 20:30:13 发布
最新推荐文章于 2024-05-26 20:30:13 发布
阅读量252 收藏 1
点赞数
分类专栏： 程序设计与算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45019478/article/details/105819725
版权

题目描述

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组数据。

接下来对于所有可以用来开会的时间段，每一个时间段输出一行。

需要满足如下规则：

在该时间段的任何时间点，都应该有至少两人在场。
在该时间段的任何时间点，至多有一位成员缺席。
该时间段的时间长度至少应该1h。
所有的成员都乐意一天24h进行工作。

举个例子，假如现在TA团队有3位成员，TT、zjm、hrz。

那么这样的时间段是合法的：会议开始之初只有TT和zjm，后来hrz加入了，hrz加入之后TT离开了，此后直到会议结束，hrz和zjm一直在场。

要求：

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

Simple 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

Simple 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

解题思路

首先要明确一个问题，TA名字和做的事是没用的输入。问题转化为给定n个区间，求出满足条件（空闲的人【m-inBusy】>=2，忙的人【inBusy】<=1）的时间段。
首先定义两个结构体，分别为busy和free，busy指的是输入的时间段，free指的是空闲的时间段：

struct busy_
{
    // busy_(string time_ ,int label_)
    // {
    //     time=time_;
    //     label=label_;
    // }
    string time;
    int label;//某事件：1开始，0结束
}busy[4009];

struct free_
{
    free_(string time_ ,int label_)
    {
        time=time_;
        label=label_;
    }
    string time;
    int label;//空闲段：1开始，0结束
};

然后进行对所有时间点的输入，这时候时间段的概念已经不重要，我们只关心它是一个任务的开始点还是结束点，时间是什么时候。使用getline()读入一整行，然后提取有效信息存储。对所有时间点进行排序，第一关键词为时间，第二关键词为开始点优先。

然后维护一个在忙的人inBusy数据，初始化为0。对于所有时间点，每次读入一个时间点，开始点的话inBusy++，结束点的话inBusy–。然后再判断，若(m-inBusy>=2&&inBusy<=1)成立，则可以开会，若此时时间点的label和空闲段上一个符合要求的点的label不一样，则可以加入该点，从而保证free区间段的时间点成对出现。

在此之后进行边界值的合并，以及不满足要求（小于1小时）的时间段的删除。注意每一个操作都在空闲段不空的情况下操作。

注意

  1. getline()前要吞回车。
  2. 定义了构造函数必须初始化。
  3. 慎用删除erase，最好的解决方案是开一个新容器存储有效点。
  4. v.size()具有无符号的返回类型。从无符号0减去1会导致回绕到一些“很大”的无符号数字，所以用一个int的临时变量来接受它。

代码

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
#include <string>
#include <climits>
#include <algorithm>
#include <queue>
#include <vector>
#include <map>
#include <stack>

#define _ ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
// #include <bits/stdc++.h>
using namespace std;

struct busy_
{
    // busy_(string time_ ,int label_)
    // {
    //     time=time_;
    //     label=label_;
    // }
    string time;
    int label;//某事件：1开始，0结束
}busy[4009];

struct free_
{
    free_(string time_ ,int label_)
    {
        time=time_;
        label=label_;
    }
    string time;
    int label;//空闲段：1开始，0结束
};

bool cmp(busy_ a,busy_ b)
{
    if(a.time!=b.time) return a.time<b.time;
    else return a.label<b.label;//开始点堆在前面，从而维持inBusy较大
}

int main()
{
    // freopen("week10/a.txt","r",stdin); 
    int T;//T组数据
    cin>>T;
    for(int group=1;group<=T;group++)
    {
        for (int i = 0; i < 4009; i++)
        {
            busy[i].time="";
        }
        vector<busy_> timeStamp;//时间戳
        int m;//m个助教
        int sumThing=0;//事件总数
        cin>>m;

        //存时间戳
        for (int i = 0; i < m; i++)
        {
            int n;//一个人的n件事
            string temp;
            cin>>n;
            getchar();
            for (int i = 0; i < 2*n; i+=2)
            {//每次新增两个时间戳，一个开始一个结束
                getline(cin,temp);
                int cur=2*sumThing+i;

                busy[cur].label=1;
                busy[cur].time.push_back(temp[0]);
                busy[cur].time.push_back(temp[1]);
                busy[cur].time.push_back(temp[2]);
                busy[cur].time.push_back(temp[3]);
                busy[cur].time.push_back(temp[5]);
                busy[cur].time.push_back(temp[6]);
                busy[cur].time.push_back(temp[8]);
                busy[cur].time.push_back(temp[9]);
                busy[cur].time.push_back(temp[11]);
                busy[cur].time.push_back(temp[12]);
                busy[cur].time.push_back(temp[14]);
                busy[cur].time.push_back(temp[15]);
                busy[cur].time.push_back(temp[17]);
                busy[cur].time.push_back(temp[18]);
                timeStamp.push_back(busy[cur]);

                busy[cur+1].label=0;
                busy[cur+1].time.push_back(temp[20]);
                busy[cur+1].time.push_back(temp[21]);
                busy[cur+1].time.push_back(temp[22]);
                busy[cur+1].time.push_back(temp[23]);
                busy[cur+1].time.push_back(temp[25]);
                busy[cur+1].time.push_back(temp[26]);
                busy[cur+1].time.push_back(temp[28]);
                busy[cur+1].time.push_back(temp[29]);
                busy[cur+1].time.push_back(temp[31]);
                busy[cur+1].time.push_back(temp[32]);
                busy[cur+1].time.push_back(temp[34]);
                busy[cur+1].time.push_back(temp[35]);
                busy[cur+1].time.push_back(temp[37]);
                busy[cur+1].time.push_back(temp[38]);
                timeStamp.push_back(busy[cur+1]);
            }
            sumThing+=n;
        }
        sort(timeStamp.begin(),timeStamp.end(),cmp);

        //统计空闲时间
        int inBusy=0;//正忙的人，m>2时1及以下有效，m=2时0有效
        vector<free_> freeStamp;//空闲时间戳
        // if(m==2&&timeStamp[0].time!="18000101000000")
        //     freeStamp.push_back(free_("18000101000000",1));
        // else if(m==2&&timeStamp[0].time=="18000101000000")
        //     inBusy++;
        // else if(m>2 &&timeStamp[0].time!="18000101000000")
        //     freeStamp.push_back(free_("18000101000000",1));
        // else if(m>2 &&timeStamp[0].time=="18000101000000"&&timeStamp[1].time!="18000101000000")
        //     freeStamp.push_back(free_("18000101000000",1)),inBusy++;
        // else inBusy++;
        
        if(timeStamp[0].time!="18000101000000") freeStamp.push_back(free_("18000101000000",1));
        for(int i=0;i<2*sumThing;i++)
        {
            if(timeStamp[i].label==1)inBusy++;
            else inBusy--;

            int tmp;//伪装的结束符
            if(freeStamp.empty()) tmp=0;
            else tmp=freeStamp.back().label;
            if(m-inBusy>=2&&inBusy<=1)
            {
                if(timeStamp[i].time=="22000101000000") continue;
                if(tmp==0)
                    freeStamp.push_back(free_(timeStamp[i].time,1));
            }
            else
            {
                if(tmp==1)
                    freeStamp.push_back(free_(timeStamp[i].time,0));
            }
        }
        if(!freeStamp.empty())
        {
            // freeStamp.front().time="18000101000000";
            if(freeStamp.back().label==1)
                freeStamp.push_back(free_("22000101000000",0));   
        }

        //去除重复边界
        if(!freeStamp.empty())
        {
            int freeStampSize=freeStamp.size();
            for (int i = 1; i <=freeStampSize-3; i++)
            //v.size()具有无符号的返回类型。从无符号0减去1会导致回绕到一些“很大”的无符号数字（这是模运算)!!!
            {
                if(freeStamp[i].time==freeStamp[i+1].time)
                {
                    freeStamp[i].label=2;
                    freeStamp[i+1].label=2;
                }
            }
            vector <free_>::iterator iter = freeStamp.begin();
            while (iter!=freeStamp.end())
            {
                if(iter->label==2) freeStamp.erase(iter);
                else iter++;
            }
        }

        //选出大于1小时时间段
        //compare是str预留字
        vector<string> ans;
        if(!freeStamp.empty())
        {
            for(int i=0;i<freeStamp.size()-1;i+=2)
            {
                int lyear=atoi(freeStamp[i].time.substr(0,4).c_str());
                int ryear=atoi(freeStamp[i+1].time.substr(0,4).c_str());
                if(ryear-lyear>=2)
                {//year
                    ans.push_back(freeStamp[i].time);
                    ans.push_back(freeStamp[i+1].time);
                    continue;
                }
                int lmonth=atoi(freeStamp[i].time.substr(4,2).c_str());
                int rmonth=atoi(freeStamp[i+1].time.substr(4,2).c_str());
                rmonth+=(ryear-lyear)*12;
                if(rmonth-lmonth>=2)
                {//month
                    ans.push_back(freeStamp[i].time);
                    ans.push_back(freeStamp[i+1].time);
                    continue;
                }
                int lday=atoi(freeStamp[i].time.substr(6,2).c_str());
                int rday=atoi(freeStamp[i+1].time.substr(6,2).c_str());
                rday+=(rmonth-lmonth)*30;
                if(rday-lday>=2)
                {//day
                    ans.push_back(freeStamp[i].time);
                    ans.push_back(freeStamp[i+1].time);
                    continue;
                }
                int lhour=atoi(freeStamp[i].time.substr(8,2).c_str());
                int rhour=atoi(freeStamp[i+1].time.substr(8,2).c_str());
                rhour+=(rday-lday)*24;
                if(rhour-lhour>=2)
                {//hour
                    ans.push_back(freeStamp[i].time);
                    ans.push_back(freeStamp[i+1].time);
                    continue;
                }
                int lmin=atoi(freeStamp[i].time.substr(10,2).c_str());
                int rmin=atoi(freeStamp[i+1].time.substr(10,2).c_str());
                rmin+=(rhour-lhour)*60;
                int lsec=atoi(freeStamp[i].time.substr(12,2).c_str());
                int rsec=atoi(freeStamp[i+1].time.substr(12,2).c_str());
                rsec+=(rmin-lmin)*60;
                if(rsec-lsec>=3600)
                {
                    ans.push_back(freeStamp[i].time);
                    ans.push_back(freeStamp[i+1].time);
                    continue;
                }
            }
        }
        
        //终于可以输出了
        cout<<"Scenario #"<<group<<":"<<endl;
        if(ans.empty())
        {
            cout<<"no appointment possible"<<endl;
            cout<<endl;
            continue;
        }
        for (int i=0;i<ans.size()-1;i+=2)
        {//MM/DD/YYYY hh:mm:ss
            string l=ans[i];
            string r=ans[i+1];
            cout<<"appointment possible from ";
            cout<<l.substr(4,2)<<'/';
            cout<<l.substr(6,2)<<'/';
            cout<<l.substr(0,4)<<' ';
            cout<<l.substr(8,2)<<':';
            cout<<l.substr(10,2)<<':';
            cout<<l.substr(12,2);
            cout<<" to ";
            cout<<r.substr(4,2)<<'/';
            cout<<r.substr(6,2)<<'/';
            cout<<r.substr(0,4)<<' ';
            cout<<r.substr(8,2)<<':';
            cout<<r.substr(10,2)<<':';
            cout<<r.substr(12,2)<<' ';
            cout<<endl;
        }
        cout<<endl;
    }
    return 0;
}
憨憨coding
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
M3模拟题--团队时间安排
weixin_43679657的博客
06-08 4602
题目描述 TA团队每周都会有很多任务，有的可以单独完成，有的则需要所有人聚到一起，开过会之后才能去做。但TA团队的每个成员都有各自的事情，找到所有人都有空的时间段并不是一件容易的事情。 给出每位助教的各项事情的时间表，你的任务是找出所有可以用来开会的时间段。 Input 第一行一个数T（T≤100），表示数据组数。 对于每组数据，第一行一个数m（2 ≤ m ≤ 20），表示TA的数量。 对于每位TA，首先是一个数n（0≤ n≤100），表示该TA的任务数。接下来n行，表示各个任务的信息，格式如下 YYYY
【AUTOSAR CANTP】深入理解CAN传输层：N-SDU数据接收与缓冲处理
weixin_46481662的博客
11-03 590
CanTp是PDU路由器和CAN接口模块之间的那个模块（看图1）。它的主要作用就是对超过8字节或者CAN FD情况下超过64字节的CAN I-PDU进行分段和重组啦。PDU路由器会把AUTOSAR COM和DCM I-PDU放到不同的通信协议上去，具体是用哪个网络系统类型（比如CAN、LIN和FlexRay）来路由，就看I-PDU标识符了。而且PDU路由器还会判断是否需要用到传输协议。最后，如果不需要进行速率转换的话，这个模块还可以充当网关的功能。
团队聚会 || 类似双指针法
人生如逆旅，我亦是行人
04-27 1478
题目 TA团队每周都会有很多任务，有的可以单独完成，有的则需要所有人聚到一起，开过会之后才能去做。但TA团队的每个成员都有各自的事情，找到所有人都有空的时间段并不是一件容易的事情。 给出每位助教的各项事情的时间表，你的任务是找出所有可以用来开会的时间段。 输入格式 第一行一个数T（T≤100），表示数据组数。 对于每组数据，第一行一个数m（2 ≤ m ≤ 20），表示TA的数量。 对于每位TA，首...
【简】题解 AWSL090429 【聚会】
lianhaoming的博客
05-03 208
【简】题解 AWSL090429 【聚会】 这题直接换根dp 记录在要转移的点的子树中有多少牛 #include<bits/stdc++.h> using namespace std; #define ll long long #define C getchar()-48 inline ll read...
【ISO15765_UDS&OBD诊断】-01-概述
「汽车电子助手」的博客
01-20 6219
全网最全UDS/OBD诊断介绍专栏：（单击下方链接皆可跳转至专栏总目录） 全网最全诊断梳理《UDS/OBD诊断&诊断描述文件CDD》总目录https://blog.csdn.net/qfmzhu/article/details/120425660 目录 1 ISO 15765标准组成 2 ISO 15765在OSI基本参考模型中的位置 3 ISO 15765中的术语 4 ISO 15765中的缩写 5 诊断网络架构 5.1 Diagnostic network诊断网络 5.2 Di
SDU程序设计思维与实践 week4 B - 四个数列 (二分)
weixin_43975891的博客
03-13 940
题目描述 ZJM 有四个数列 A,B,C,D，每个数列都有 n 个数字。ZJM 从每个数列中各取出一个数，他想知道有多少种方案使得 4 个数的和为 0。当一个数列中有多个相同的数字的时候，把它们当做不同的数对待。请你帮帮他吧！ 输入描述 第一行：n（代表数列中数字的个数） （1≤n≤4000） 接下来的 n 行中，第 i 行有四个数字，分别表示数列 A,B,C,D 中的第 i 个数字（数字不超过 ...
SDU程序设计与实践模拟Week6
TIM__one的博客
03-30 708
SDU程序设计与实践模拟Week6A- 掌握魔法の东东 II题解C++代码 A- 掌握魔法の东东 II Input&&Output: sample: #Input 5 2 1 0 3 1 #Output 0 0 0 0 8 0 12 36 0 #Input 25 4 0 0 24 3 #Output 0 2 18 0 0 644 1656 36432 113344 题解 1....
海德堡印刷机显示屏维修SDU10_00.785.1384显示器维修故障概述
bjtpzd的博客
12-07 4017
海德堡印刷机显示屏维修，海德堡电路板维修，驱动器维修,显示屏有线条、亮度暗、不显示等故障维修； 海德堡印刷机维修项目： 海德堡CD102 控制板维修（海德堡风泵驱动板维修）、海德堡水辊驱动板维修，海德堡喷粉机 控制盒维修、海德堡油压控制板维修、海德堡墨牙控制板维修、海德堡主电机调速板维修、 海德堡主PLC 维修、海德堡操作台控制板维修、海德堡升降台电路板维修、海德堡CPU 维修、 海德堡变频器维修、海德堡驱动器维修、海德堡显示屏维修、海德堡驱动维修、东洋变频器 维修（海德堡印刷机用） 海德堡印刷机电脑..
AUTOSAR_SWS_DiagnosticCommunicationManager-2
最新发布
qq_39774096的博客
05-26 741
诊断请求，无论与正在处理的请求是否源自同一通道，都会被接受(Dcm_StartOfReception返回BUFREQ_OK)，但是都不会进行处理(即：不进行S3Server timer的重制)。※Note3：Dcm_StartOfReception()的参数 TpS-duLength等于0，函数也会返回BUFREQ_E_NOT_OK，不会再进行下一步的处理。相同的DcmDslConnection的后续请求不会被接受。且新的请求的优先度与当前处理请求相同或者更低。返回BUFREQ_E_NOT_OK。
[SDU软件工程实践]Blog9-修复Hive
Stardust_5322的博客
11-22 1346
2021SC@SDUSC 目录发生什么了？解决它使用wordcount来检查hadoop针对找不到主类的解决方法后续 发生什么了？ 这天，我打开hive，准备测试功能。hive首先是无法进入了，这是因为我很久没有操作过hdfs，它自己进入了安全模式。解除安全模式再启动，插入个数据，然后 这个程序就这样卡死在这里了。 解决它 使用wordcount来检查hadoop 然后我就疯狂在网上各种查，最后基本都指向了hadoop出现问题。我使用hadoop的官方案例wordcount，但是这个案例仍然卡住了。 对于
sdu.zip_SQLsever
09-23
学生管理系统，SQLSever版，直接附加数据库文件就可以了
数据结构课设_sdu_cs_大二_输者树外排序代码
04-26
输者树实现磁盘文件外排序内容
sdu_android_programming
02-10
sdu_android_programming
sdu.rar_SDU
09-23
山东大学亚洲高校软件设计大赛
sdu_dm820_2015
06-08
这是什么 这是一个学习 Jolie 和微服务编程基础知识的简单场景。 在本 repo 中提供的初始示例中，我们坚持 Jolie 的基本特征，即没有会话（相关集）或架构组合。 在你开始之前 订阅 开始此存储库。...
SDU_week11_水题汇总
憨憨的博客
05-07 314
目录A - 必做题11-1题目描述思路代码B - 必做题11-2题目描述思路代码C - 必做题11-3题目描述思路代码D - 必做题11-4题目描述思路代码 A - 必做题11-1 题目描述 蒜头君从现在开始工作，年薪 N 万。他希望在蒜厂附近买一套 60 平米的房子，现在价格是 200万。假设房子价格以每年百分之 K 增长，并且蒜头君未来年薪不变，且不吃不喝，不用交税，每年所得 N万全都积攒起来...
SDU_week3_A - 选数问题（动态规划）
憨憨的博客
04-28 288
题目描述 Given n positive numbers, ZJM can select exactly K of them that sums to S. Now ZJM wonders how many ways to get it! Input The first line, an integer T<=100, indicates the number of test cases....
SDU_week4_A - DDL 的恐惧（贪心+作业调度问题）
憨憨的博客
04-28 243
题目描述 ZJM 有 n 个作业，每个作业都有自己的 DDL，如果 ZJM 没有在 DDL 前做完这个作业，那么老师会扣掉这个作业的全部平时分。 所以 ZJM 想知道如何安排做作业的顺序，才能尽可能少扣一点分。 请你帮帮他吧！ Input 输入包含T个测试用例。输入的第一行是单个整数T，为测试用例的数量。 每个测试用例以一个正整数N开头(1<=N<=1000)，表示作业的数量。 然后两...
com.sdu.didi.gsui_5.4.6_426.apk.1.1
09-07
com.sdu.didi.gsui_5.4.6_426.apk.1.1 是一个APK文件的名称。APK 是Android应用程序包的缩写，它是Android操作系统上的应用程序的安装包。这个APK文件的名称表明它是滴滴出行公司开发的某个版本的一个应用程序。 ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值