算法刷题day06

引言

今天是刷题的第六天的看看之前刷过的题基本快刷的差不多了，然后就开始刷一写新的题了。今天搞得是模拟和枚举和归并排序，关于这个归并排序我才感受到，这个模板一定要多写，写多了，自己心里都能想出来，然后每个地方细节也就能更加深刻理解了，加油吧！

---

一、移动距离

标签：模拟
思路：首先像这种要确定行号和列号的，从0开始才能算出来，行列分别为 n/w 和 n%w ，然后就是算纵向距离加上横向距离，纵向是没问题的，横向就是把它变成正常排序的就一减就行了，然后发现奇数行的才要变0 ~ w-1, 1 ~ w-2这样互相变，那就用w-1 - n%w就行了

题目描述：

X星球居民小区的楼房全是一样的，并且按矩阵样式排列。

其楼房的编号为 1,2,3…当排满一行时，从下一行相邻的楼往反方向排号。

比如：当小区排号宽度为 6 时，开始情形如下：
1  2  3  4  5  6
12 11 10 9  8  7
13 14 15 .....
我们的问题是：已知了两个楼号 m 和 n，需要求出它们之间的最短移动距离（不能斜线方向移动）。

输入格式
输入共一行，包含三个整数 w,m,n，w 为排号宽度，m,n 为待计算的楼号。

输出格式
输出一个整数，表示 m,n 两楼间最短移动距离。

数据范围
1≤w,m,n≤10000 ,
输入样例：
6 8 2
输出样例：
4

示例代码：

#include 
#include 
#include 

using namespace std;

int main()
{
    int w, m, n;
    cin >> w >> m >> n;
    m--, n--;
    
    int r1 = m / w, r2 = n / w;
    int c1 = m % w, c2 = n % w;
    if(r1 % 2 == 1)
    {
        c1 = w - 1 - c1;
    }
    if(r2 % 2 == 1)
    {
        c2 = w - 1 - c2;
    }
    
    int res = abs(r1-r2) + abs(c1-c2);
    
    cout << res << endl;
    
    return 0;
}

---

二、日期问题

标签：模拟、枚举
思路：日期问题基本都是这样先看时间复杂度可以不，然后就是枚举所有的数0000-00-00，判断其是否为日期，这道题而且在abc cab cba这块有理解问题，应该是abc不动，看年月日对应的是哪个，而不是年月日不动，看年对应a，月对应b，日对应c，这是错误的
题目描述：

小明正在整理一批历史文献。这些历史文献中出现了很多日期。

小明知道这些日期都在1960年1月1日至2059年12月31日。

令小明头疼的是，这些日期采用的格式非常不统一，有采用年/月/日的，有采用月/日/年的，还有采用日/月/年的。

更加麻烦的是，年份也都省略了前两位，使得文献上的一个日期，存在很多可能的日期与其对应。

比如02/03/04，可能是2002年03月04日、2004年02月03日或2004年03月02日。

给出一个文献上的日期，你能帮助小明判断有哪些可能的日期对其对应吗？

输入格式
一个日期，格式是”AA/BB/CC”。

即每个’/’隔开的部分由两个 0-9 之间的数字（不一定相同）组成。

输出格式
输出若干个不相同的日期，每个日期一行，格式是”yyyy-MM-dd”。

多个日期按从早到晚排列。

数据范围
0≤A,B,C≤9
输入样例：
02/03/04
输出样例：
2002-03-04
2004-02-03
2004-03-02

示例代码：

#include 
#include 

using namespace std;

int a, b, c;

//abc  cab  cba
bool check(int y, int m, int d)
{
    int t1 = y % 100;
    if(! ((t1 == a && m == b && d == c) ||  (t1 == c && m == a && d == b) ||  (t1 == c && m == b && d == a))) return false;
    
    int days[13] = {0, 31,28,31,30,31,30,31,31,30,31,30,31};
    if((m != 2) && (d > days[m])) return false;
    else if(m == 2)
    {
        int is_leapyear = y % 400 == 0 || y % 100 != 0 && y % 4 == 0;
        if(d > 28 + is_leapyear) return false;
    }
    
    return true;
}

int main()
{
    scanf("%d/%d/%d", &a, &b, &c);
    
    for(int y = 1960; y <= 2059; y++)
    {
        for(int m = 1; m <= 12; ++m)
        {
            for(int d = 1; d <= 31; ++d)
            {
                if(check(y,m,d)) printf("%d-%02d-%02d\n", y, m, d);
            }
        }
    }
    
    return 0;
}

---

三、航班时间

标签：模拟
思路：这个就是先把思路想好，然后就是处理输入的问题了，然后多细心检查就行了
题目描述：

小 h 前往美国参加了蓝桥杯国际赛。

小 h 的女朋友发现小 h 上午十点出发，上午十二点到达美国，于是感叹到“现在飞机飞得真快，两小时就能到美国了”。

小 h 对超音速飞行感到十分恐惧。

仔细观察后发现飞机的起降时间都是当地时间。

由于北京和美国东部有 12 小时时差，故飞机总共需要 14 小时的飞行时间。

不久后小 h 的女朋友去中东交换。

小 h 并不知道中东与北京的时差。

但是小 h 得到了女朋友来回航班的起降时间。

小 h 想知道女朋友的航班飞行时间是多少。

对于一个可能跨时区的航班，给定来回程的起降时间。

假设飞机来回飞行时间相同，求飞机的飞行时间。

输入格式
一个输入包含多组数据。

输入第一行为一个正整数 T，表示输入数据组数。

每组数据包含两行，第一行为去程的起降时间，第二行为回程的起降时间。

起降时间的格式如下:

h1:m1:s1 h2:m2:s2
h1:m1:s1 h3:m3:s3 (+1)
h1:m1:s1 h4:m4:s4 (+2)
第一种格式表示该航班在当地时间h1时m1分s1秒起飞，在当地时间当日h2时m2分s2秒降落。

第二种格式表示该航班在当地时间h1时m1分s1秒起飞，在当地时间次日h2时m2分s2秒降落。

第三种格式表示该航班在当地时间h1时m1分s1秒起飞，在当地时间第三日h2时m2分s2秒降落。

输出格式
对于每一组数据输出一行一个时间hh:mm:ss，表示飞行时间为hh小时mm分ss秒。

注意，当时间为一位数时，要补齐前导零，如三小时四分五秒应写为03:04:05。

数据范围
保证输入时间合法（0≤h≤23,0≤m,s≤59），飞行时间不超过24小时。

输入样例：
3
17:48:19 21:57:24
11:05:18 15:14:23
17:21:07 00:31:46 (+1)
23:02:41 16:13:20 (+1)
10:19:19 20:41:24
22:19:04 16:41:09 (+1)
输出样例：
04:09:05
12:10:39
14:22:05

示例代码：

#include 
#include 
#include 

using namespace std;

typedef long long LL;

string t, line;

//当地时间1 + 时差 + 飞行时间 = 当地时间2
//当地时间3 - 时差 + 飞行时间 = 当地时间4
//2*x + h1+h3 = h2+h4;

LL get1(int h, int m, int s, int a)
{
    return (LL)h * 3600 + m * 60 + s + a*24*3600;
}

int T;

int main()
{
    scanf("%d", &T);
    getline(cin, t);
    
    while(T--)
    {
        int h1, m1, s1, h2, m2, s2, h3, m3, s3, h4, m4, s4;
        
        getline(cin, line);
        int a1 = 0, a2 = 0;
        if(line.back() == ')')
        {
            a1 = line[20] - '0';
            line = line.substr(0,17);
        }
        sscanf(line.c_str(), "%d:%d:%d %d:%d:%d", &h1, &m1, &s1, &h2, &m2, &s2);
        
        getline(cin, line);
        if(line.back() == ')')
        {
            a2 = line[20] - '0';
            line = line.substr(0,17);
        }
        sscanf(line.c_str(), "%d:%d:%d %d:%d:%d", &h3, &m3, &s3, &h4, &m4, &s4);
        
        // printf("%d %d %d   %d %d %d %d\n", h1,m1,s1, h2,m2,s2,a1);
        // printf("%d %d %d   %d %d %d %d\n", h3,m3,s3, h4,m4,s4,a2);
        
        // int r = get1(h2,m2,s2,a1) - get1(h1,m1,s1,0);
        // cout << r << endl;
        // cout << r / 3600 << " " << r %3600/60 << " " << r % 60 << endl;
        LL res = 0;
        res = (get1(h2,m2,s2,a1) + get1(h4,m4,s4,a2) - get1(h1,m1,s1,0) - get1(h3,m3,s3,0)) / 2;
        //cout << res << endl;
        
        //24 * 60 * 60
        h1 = res / 3600, m1 = res % 3600 / 60, s1 = res % 60;
        printf("%02d:%02d:%02d\n", h1, m1, s1);
    }
    
    return 0;
}

---

四、外卖店优先级

标签：模拟

思路：如果按照正常逻辑:按时间枚举，t时刻，每个订单的变化，然后每个店的变化，就是O(N^2)也就是1e10的复杂度，已经超了，但还是可以过90%的数据，对于蓝桥杯是可以拿到不错的分数的。但平时练习还是要以全过为主。思路就是：枚举每个订单，因为只有1e5个，所以按时间排序，只处理订单，然后遇到一个订单有个last数组，存的上次的订单时间就可以拿这次的时间与上次相减，加的就正常加，最后再在T时刻枚举每个店铺，再统计last数组，刷新优先级就行了。

题目描述：

“饱了么”外卖系统中维护着 N 家外卖店，编号 1∼N。

每家外卖店都有一个优先级，初始时 (0 时刻) 优先级都为 0。

每经过 1 个时间单位，如果外卖店没有订单，则优先级会减少 1，最低减到 0；而如果外卖店有订单，则优先级不减反加，每有一单优先级加 2。

如果某家外卖店某时刻优先级大于 5，则会被系统加入优先缓存中；如果优先级小于等于 3，则会被清除出优先缓存。

给定 T 时刻以内的 M 条订单信息，请你计算 T 时刻时有多少外卖店在优先缓存中。

输入格式
第一行包含 3 个整数 N,M,T。

以下 M 行每行包含两个整数 ts 和 id，表示 ts 时刻编号 id 的外卖店收到一个订单。

输出格式
输出一个整数代表答案。

数据范围
1≤N,M,T≤105,1≤ts≤T,1≤id≤N
输入样例：
2 6 6
1 1
5 2
3 1
6 2
2 1
6 2
输出样例：
1
样例解释
6 时刻时，1 号店优先级降到 3，被移除出优先缓存；2 号店优先级升到 6，加入优先缓存。
所以是有 1 家店 (2 号) 在优先缓存中。

示例代码：

#include 
#include 
#include 

#define x first
#define y second

using namespace std;

typedef pair<int,int> PII;

const int N = 1e5+10;

int n, m, T;
bool st[N];
int score[N], last[N];
PII order[N];

int main()
{
    scanf("%d%d%d", &n, &m, &T);
    for(int i = 0; i < m; ++i) scanf("%d%d", &order[i].x, &order[i].y);
    
    sort(order, order+m);
    
    for(int i = 0; i < m;)
    {
        int j = i;
        while(j < m && order[i] == order[j]) j++;
        int t = order[i].x, id = order[i].y, cnt = j - i;
        i = j;
        
        score[id] -= t - last[id] - 1;
        score[id] = max(0, score[id]);
        if(score[id] <= 3) st[id] = false;
        
        score[id] += cnt * 2;
        if(score[id] > 5) st[id] = true;
        
        last[id] = t;
    }
    
    for(int i = 1; i <= n; ++i)
    {
        if(T != last[i])
        {
            score[i] -= T - last[i];
            score[i] = max(0, score[i]);
            if(score[i] <= 3) st[i] = false;
        }
    }
    
    int res = 0;
    for(int i = 1; i <= n; ++i) 
    {
        if(st[i]) res++;
    }
    
    printf("%d\n", res);
    
    return 0;
}

---

五、逆序对的数量

标签：归并排序、模板题
思路：没啥思路就是背模板
题目描述：

给定一个长度为 n 的整数数列，请你计算数列中的逆序对的数量。

逆序对的定义如下：对于数列的第 i 个和第 j 个元素，如果满足 ia[j]，则其为一个逆序对；否则不是。

输入格式
第一行包含整数 n，表示数列的长度。

第二行包含 n 个整数，表示整个数列。

输出格式
输出一个整数，表示逆序对的个数。

数据范围
1≤n≤100000，数列中的元素的取值范围 [1,109]。

输入样例：
6
2 3 4 5 6 1
输出样例：
5

示例代码：

#include 
#include 

using namespace std;

typedef unsigned long long ULL;

const int N = 1e5+10;

int a[N], backup[N];
int n;

ULL merge_sort(int l, int r)
{
    if(l >= r) return 0;
    
    int mid = l + r >> 1;
    
    ULL res = merge_sort(l, mid);
    res += merge_sort(mid+1, r);
    
    int i = l, j = mid + 1, k = 0;
    while(i <= mid && j <= r)
    {
        if(a[i] <= a[j]) 
        {
            backup[k++] = a[i++];
        }
        else
        {
            backup[k++] = a[j++];
            res += mid - i + 1;
        }
    }
    
    while(i <= mid) backup[k++] = a[i++];
    while(j <= r) backup[k++] = a[j++];
    
    for(int i = l, j = 0; i <= r; ++i, ++j)
    {
        a[i] = backup[j];
    }
    
    return res;
}

int main()
{
    cin >> n;
    for(int i = 0; i < n; ++i) cin >> a[i];
    
    ULL res = merge_sort(0, n-1);
    
    cout << res << endl;
    
    return 0;
}

---

六、总结

• 一道题先想清楚思路再去做，不要都没想好呢，就一股脑的敲代码，浪费时间不说，思路都被搞乱了
• 经常出错的就是判断闰年的条件每次应该是else if(m == 2)经常直接就else了，明显是不对的