A - 签到题
题意：
TT有一个A×B×C的长方体。这个长方体是由A×B×C个1×1×1的小正方体组成的。
现在TT想给每个小正方体涂上颜色。
需要满以下三点条件：
每个小正方体要么涂成红色，要么涂成蓝色。
所有红色的小正方体组成一个长方体。
所有蓝色的小正方体组成一个长方体。
现在TT想知道红色小正方体的数量和蓝色小正方体的数量的差异。
你需要找到红色正方体的数量与蓝色正方体的数量差值的绝对值的最小值。
即min{|红色正方体数量 - 蓝色正方体数量|}。
Input
输入仅一行，三个数 A B C ( 2 ≤ A , B , C ≤ 1 0 9 ) A B C (2≤A,B,C≤10^9) ABC(2≤A,B,C≤109)。
Output
输出一个数字。
即差值绝对值的最小值。
Sample Input
3 3 3
2 2 4
5 3 5
Sample Output
9
0
15
思路做法：
读题可以知道判断标准在最长的边长上。
若最长的边长为偶数，则可以平分，答案为0。
否则答案为另两条边长的乘积。
总结:
为防止溢出，直接拿long long来存数据。
也可以把3个数排个序，谁小谁大一目了然。但是思路很简单就直接用if判断语句来写了。
代码:
#include <stdio.h>
#include <algorithm>
using namespace std;
#define ll long long
int main(){
ll a, b, c;
scanf("%lld%lld%lld", &a, &b ,&c);
if(a >= b && a >= c){
if(a % 2) printf("%lld\n", b * c);
else printf("0\n");
}else if(b >= a && b >= c){
if(b % 2) printf("%lld\n", a * c);
else printf("0\n");
}else if(c >= a && c >= b){
if(c % 2) printf("%lld\n", a * b);
else printf("0\n");
}
return 0;
}
B - 团 队 聚 会 （不支持C++11）
题意：
TA团队每周都会有很多任务，有的可以单独完成，有的则需要所有人聚到一起，开过会之后才能去做。但TA团队的每个成员都有各自的事情，找到所有人都有空的时间段并不是一件容易的事情。
给出每位助教的各项事情的时间表，你的任务是找出所有可以用来开会的时间段。
Input
第一行一个数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天的，数据保证不含有不合法的日期。
注意每件事务的结束时间点也即是该成员可以开始参与开会的时间点。
Output
对于每一组数据，首先输出一行"Scenario #i:"，i即表明是第i组数据。
接下来对于所有可以用来开会的时间段，每一个时间段输出一行。
需要满足如下规则：
1.在该时间段的任何时间点，都应该有至少两人在场。
2.在该时间段的任何时间点，至多有一位成员缺席。
3.该时间段的时间长度至少应该1h。
所有的成员都乐意一天24h进行工作。
举个例子，假如现在TA团队有3位成员，TT、zjm、hrz。
那么这样的时间段是合法的：会议开始之初只有TT和zjm，后来hrz加入了，hrz加入之后TT离开了，此后直到会议结束，hrz和zjm一直在场。
要求：
1.输出满足条件的所有的时间段，尽管某一段可能有400年那么长。
2.时间点的格式为MM/DD/YYYY hh:mm:ss。
3.时间段的输出格式为"appointment possible from T0 to T1"，其中T0和T1均应满足时间点的格式。
4.严格按照格式进行匹配，如果长度不够则在前面补前导0。
5.按时间的先后顺序输出各个时间段。
6.如果没有合适的时间段，输出一行"no appointment possible"。
7.每组数据末尾须打印额外的一行空行。
Sample 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
Sample 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
思路做法：
用结构体Time记录时间点，并重载小于号，Table记录时间表（包含开始时间点和结束时间点）。
将每个TA的每个时间表输入后，用集合记录每个时间表的左右端点。
接下来将集合内的时间点取出并从左到右逐区间用函数isOk判定（set已经排好序）。
对于给定的一个时间区间，对所有TA遍历，看他是否有时间，要注意是逐个小区间判定，所以不可能有一个
t
t
t，
t
.
s
>
s
&
&
t
.
e
<
e
t.s>s\&\&t.e<e
t.s>s&&t.e<e，所以可以判断是否
t
.
s
<
=
s
&
&
t
.
e
>
=
e
t.s <= s \&\& t.e >= e
t.s<=s&&t.e>=e，若是，则该TA不能开会。
若当前区间可行，则令右端点ri++，直到不可行，判定计算出的区间是否满足时间长度，若满足，就可以把左右端点记录在ans中。之后再用循环找出下一个可行点，进而往复循环找出所有可行时间段。
总结:
一开始的思路是差分法，但是400年的时间点换算成秒太长，开辟数组都报错。
第二个思路是把所有的时间表记录后排序，遍历所有时间表看之间的关系，但是具体的时间段是否空闲很难逐个判定。
之后的关键一点是：能够记录在ans中的时间点一定是从输入的时间表的左端点或右端点中确定的，所以找出所有端点，遍历并确定在小区间内是否空闲。另外每一个小区间判定，正好不可能出现一个时间表占用了一部分给定时间表的情况，而只能是不占用或者全占用。
中间判定时间时先用的>3600s，但是=也是可以的。注意int转long long。
要从题目给出的信息中提取出有用信息，比如时间点有用，而具体的事件没用，结构体Time和Table就没必要理会。可以用<重载>=和<=。
代码:
#include <stdio.h>
#include <vector>
#include <set>
using namespace std;
#define ll long long
struct Time{
int Y, M, D, h, m, s;
Time(int _Y, int _M, int _D, int _h, int _m, int _s)
:Y(_Y), M(_M), D(_D), h(_h), m(_m), s(_s){}
Time(int *t){
Y = t[0]; M = t[1]; D = t[2];
h = t[3]; m = t[4]; s = t[5];
}
bool operator<(const Time& t) const {
if(Y != t.Y) return Y < t.Y;
if(M != t.M) return M < t.M;
if(D != t.D) return D < t.D;
if(h != t.h) return h < t.h;
if(m != t.m) return m < t.m;
return s < t.s;
}
bool operator>=(const Time& t) const {
return !(*this < t);
}
bool operator<=(const Time& t) const {
return !(t < *this);
}
};
struct Table{
Time s;
Time e;
Table(Time _s, Time _e):s(_s), e(_e){}
};
int m;
set<Time> time_set;
vector<Time> time_point;
vector<Table> ta[25], ans; // 20+5
bool isNotBusy(int i, Time s, Time e){
for(int j = 0; j < ta[i].size(); ++j){
Table t = ta[i][j];
if(t.s <= s && t.e >= e) return false;
// 不可能有一个t，t.s>s&&t.e<e 因为s,e都是time_set里紧挨着的
}
return true;
}
bool isOk(Time s, Time e){
int cnt = 0;
for(int i = 1; i <= m; ++i){ // 对每一个TA进行判断，是否可以开会
if(isNotBusy(i, s, e)) cnt++;
}
if(cnt >= 2 && cnt >= m-1) return true;
return false;
}
bool isOver1h(Time s, Time e){
ll st = (((((1ll*s.Y-1800)*12+s.M-1)*30+s.D-1)*24+s.h)*60+s.m)*60+s.s;
ll et = (((((1ll*e.Y-1800)*12+e.M-1)*30+e.D-1)*24+e.h)*60+e.m)*60+e.s;
if(et - st >= 3600) return true;
return false;
}
int main(){
int t; scanf("%d", &t);
Time ss(1800, 1, 1, 0, 0, 0), ee(2200, 1, 1, 0, 0, 0);
for(int grp = 1; grp <= t; ++grp){ // 每一组数据
scanf("%d", &m); // TA数
// 初始化
for(int i = 1; i <= m; ++i) ta[i].clear();
ans.clear(); time_set.clear(); time_point.clear();
time_set.insert(ss); time_set.insert(ee);
for(int i = 1; i <= m; ++i){
int n; scanf("%d", &n); // 任务数
for(int j = 1; j <= n; ++j){
int start[6], end[6];
for(int k = 0; k < 6; ++k) scanf("%d", &start[k]);
for(int k = 0; k < 6; ++k) scanf("%d", &end[k]);
char info[105]; scanf("%[^\n]", info);
Time s = Time(start), e = Time(end);
time_set.insert(s); time_set.insert(e);
ta[i].push_back(Table(s, e));
}
}
for(set<Time>::iterator i = time_set.begin(); i != time_set.end(); i++){
// ans的所有可能都在端点上 set已经排好序 可以按序便历
time_point.push_back(*i);
}
// 对每一个区间进行判断
int le = 0, ri = 0, len = time_point.size();
while(ri < len){
// 判断[ri, ri+1]是否可行 端点必须紧挨着
// 如果可行 ri++ 防止ri越界要小于len-1
while(ri < len-1 && isOk(time_point[ri], time_point[ri+1])) ri++;
if(isOver1h(time_point[le], time_point[ri]))
ans.push_back(Table(time_point[le], time_point[ri]));
le = ri + 1;
// [le, le+1] 找一个可行的开始点
while(le < len-1 && (!isOk(time_point[le], time_point[le+1]))) le++;
ri = le + 1;
}
printf("Scenario #%d:\n", grp);
if(ans.size() == 0){
printf("no appointment possible\n");
}else{
for(int i = 0; i < ans.size(); ++i){
Time s = ans[i].s, e = ans[i].e;
printf("appointment possible from %02d/%02d/%d %02d:%02d:%02d to %02d/%02d/%d %02d:%02d:%02d\n"
, s.M, s.D, s.Y, s.h, s.m, s.s, e.M, e.D, e.Y, e.h, e.m, e.s);
}
}
printf("\n");
}
return 0;
}
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
