AtCoder ABC001D - 感雨時刻の整理 题解及翻译（差分，排序，占位输出方式）

感雨時刻の整理

一、题目描述

给定一个变量 m, 之后是 m 组时间段
以“时分-时分”给出
如样例1输入：

4
1148-1210
1323-1401
1106-1123
1129-1203

要求将其转化之后再合并
转化方式为，起始时间向前移动到能被5整除，结束时间向后移动到能被5整除，如：
1148-1210
转化为
1145-1210
合并方式为，将重复的时间段合并
如样例1输出：

1105-1210
1320-1405

二、算法分析及代码

1. 时间的转化与输出

（1）转化

int change(int x,int v){
    int res=1;
    int a=x/100;
    int b=x%100;
    res+=a*12;
    res+=b/5;
    if(v==2 && b%5!=0) res++;
    return res;
}

x 代表需要转化的时间，v=1 代表其是起始时间，v=2 代表其是结束时间。
① 对于起始时间
转化方式为以5分钟为一段来整除
比如 0001/5=0,
则 0001转化为0
② 对于结束时间
转化方式为以5分钟为一段来整除，再加1
比如 0006/5=1,
则 0006转化为1+1=2
特别的是，当结束时间本身就能被5整除时，则不用加1
比如 0010/5=2, 且0010 mod 5=0,
则0010转化为2

为了防止数组下标越界，笔者将转化后的时间又向后移了一位，所以 res 初始时为1

（2）输出

void print(int l,int r){
    l--;
    r--;
    int a=l/12;
    int b=5*(l%12);
    int c=r/12;
    int d=5*(r%12);
    printf("%0*d",2,a);
    printf("%0*d",2,b);
    printf("-");
    printf("%0*d",2,c);
    printf("%0*d",2,d);
    printf("\n");
}

l 和 r 都是转化处理后的时间，先将其后移的一位移回去，再还原时和分，然后用 printf 语句的占位方式将其输出

printf("%0*d",2,a);

表示将该整数前面用0填充，填充之后的位数为2

print(1,2)

输出为：

0000-0005

2. 解法1-利用差分进行区间维护（时间复杂度O(n)）

（1）一个思路
将时间全部按上述 change 函数转化后，获得了若干个时间段，这些时间段转化后的值不会超过24*12+1=289，可以开一个长度大于289的数组 p, 对于每个时间段[l,r], 将 l 到 r 之间的值全部加1，最后统计所有连续的非0序列，将其起点和终点转化后输出即可。
比如对于如下序列

1	2	3	4	5	6	7	8	9
1	1	0	0	0	0	1	1	1

则

print(1,2);
print(7,9);

即可。
但当遇到两个区间相邻时，该方法无法处理。
如果有如下情况：

1	2	3	4	5
1	1	1	1	0

对于区间[1,2],[3,4]
[1,4]
[1,1],[2,4]
都会被处理成如上表格的情况，最终输出一个区间[1,4]
但显然 [1,2] 和 [3,4] 是不该被合并的

（2）优化后的思路
解决方法则是
将处理后的时间乘以 2，则对于区间 [1,2],[3,4] 的合并变为了合并 [2,4],[6,8]

1	2	3	4	5	6	7	8	9	10
0	1	1	1	0	1	1	1	0	0
这样就可以处理区间相邻的情况了。

（3）代码如下：

#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
const int N=305*2;
int w[N];
int p[N];
int n;
int change(int x,int v){
    int res=1;
    int a=x/100;
    int b=x%100;
    res+=a*12;
    res+=b/5;
    if(v==2 && b%5!=0) res++;
    return res;
}
void insert(int l,int r,int c){
    p[l]+=c;
    p[r+1]-=c;
}
void print(int l,int r){
    l/=2;
    r/=2;
    l--;
    r--;
    int a=l/12;
    int b=5*(l%12);
    int c=r/12;
    int d=5*(r%12);
    printf("%0*d",2,a);
    printf("%0*d",2,b);
    printf("-");
    printf("%0*d",2,c);
    printf("%0*d",2,d);
    printf("\n");
}
int main(){
    
    cin>>n;
    for(int i=0;i<n;i++){
        int a,b;
        scanf("%d-%d",&a,&b);
        insert(change(a,1)*2,change(b,2)*2,1);
        
    }
    for(int i=1;i<=290*2;i++) p[i]+=p[i-1];
    int l=0;
    int r=0;
    for(int i=1;i<=290*2;i++){
        if(!p[i] && l){
            print(l,r);
            l=0;
            r=0;
        }
        if(p[i] && !l){
            l=i;
            r=i;
        }
        if(p[i] && l){
            r=i;
        }
    }
    
    
    return 0; 
    
}

3. 解法2-对区间排序（时间复杂度O(n*log(n))）

仍要先对时间进行转化，转化后按区间左端点排序。然后枚举区间，如果下一个区间的左端点小于等于当前区间的右端点，则进行合并。
代码如下：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#define x first
#define y second
using namespace std;
typedef pair<int,int> PII;
const int N=305;
const int M=30005;
int w[N];
int n,m;
PII p[M];
int change(int x,int v){
    int res=1;
    int a=x/100;
    int b=x%100;
    res+=a*12;
    res+=b/5;
    if(v==2 && b%5!=0) res++;
    return res;
}
void print(int l,int r){
    l--;
    r--;
    int a=l/12;
    int b=5*(l%12);
    int c=r/12;
    int d=5*(r%12);
    printf("%0*d",2,a);
    printf("%0*d",2,b);
    printf("-");
    printf("%0*d",2,c);
    printf("%0*d",2,d);
    printf("\n");
}
int main(){
    
    cin>>n;
    for(int i=0;i<n;i++){
        int a,b;
        scanf("%d-%d",&a,&b);
        p[++m]={change(a,1),change(b,2)};
        //cout<<p[m].x<<' '<<p[m].y<<endl;
    }
    sort(p+1,p+m+1);
    int l=0;
    int r=0;
    for(int i=1;i<=m;i++){
        if(l==0) l=p[i].x,r=p[i].y;
        if(p[i+1].x<=r) r=max(r,p[i+1].y);
        if(p[i+1].x>r){
            print(l,r);
            l=0;
            r=0;
        }
    }
    if(l) print(l,r);
    
    return 0; 
    
}