蓝桥杯C++ AB组辅导课 第四讲 枚举、模拟与排序 Acwing

例题

AcWing 1210. 连号区间数

小明这些天一直在思考这样一个奇怪而有趣的问题:

在 1∼N 的某个排列中有多少个连号区间呢?

这里所说的连号区间的定义是:

如果区间 [L,R] 里的所有元素(即此排列的第 L 个到第 R 个元素)递增排序后能得到一个长度为 R−L+1 的“连续”数列,则称这个区间连号区间。

当 N 很小的时候,小明可以很快地算出答案,但是当 N 变大的时候,问题就不是那么简单了,现在小明需要你的帮助。

输入格式
第一行是一个正整数 N,表示排列的规模。

第二行是 N 个不同的数字 Pi,表示这 N 个数字的某一排列。

输出格式
输出一个整数,表示不同连号区间的数目。

数据范围
1≤N≤10000,
1≤Pi≤N
输入样例1:
4
3 2 4 1
输出样例1:
7
输入样例2:
5
3 4 2 5 1
输出样例2:
9
样例解释
第一个用例中,有 7 个连号区间分别是:[1,1],[1,2],[1,3],[1,4],[2,2],[3,3],[4,4]
第二个用例中,有 9 个连号区间分别是:[1,1],[1,2],[1,3],[1,4],[1,5],[2,2],[3,3],[4,4],[5,5]

思路 :

  • 1e4,可以枚举所有区间
  • 注意到输入数据保证每个元素值都不同,因此,连续 等价于 最大值减最小值等于区间长度-1
  • 显然不可能通过每次排序来得到每个区间的最大最小值,因为我们顺序枚举出了所有区间,因此可以采用动态更新的方法
#include 
using namespace std;

const int N = 1e4 + 10;

int n, a[N];

int main()
{
    cin >> n;
    for (int i = 1; i <= n && cin >> a[i]; i ++ );
    
    int res = 0;
    
    for (int i = 1; i <= n; i ++ )
    {
        int mx = 0, mi = 1e5;
        for (int j = i; j <= n; j ++ )
        {
            mx = max(mx, a[j]);
            mi = min(mi, a[j]);
            if (j - i + 1 == mx - mi + 1) res ++ ;
        }
    }
    cout << res;
}

AcWing 1236. 递增三元组

给定三个整数数组

A=[A1,A2,…AN],
B=[B1,B2,…BN],
C=[C1,C2,…CN],

请你统计有多少个三元组 (i,j,k) 满足:

1≤i,j,k≤N
Ai 输入格式
第一行包含一个整数 N。

第二行包含 N 个整数 A1,A2,…AN。

第三行包含 N 个整数 B1,B2,…BN。

第四行包含 N 个整数 C1,C2,…CN。

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

数据范围
1≤N≤105,
0≤Ai,Bi,Ci≤105
输入样例:
3
1 1 1
2 2 2
3 3 3
输出样例:
27

思路(二分):

  • 二分前记得先sort
#include 
#include 
using namespace std;

typedef long long ll;

const int N = 1e5 + 10;

int n;
int a[3][N];

int main()
{
    cin >> n;
    for (int i = 0; i < 3; i ++ )
        for (int j = 1; j <= n; j ++ )
            cin >> a[i][j];
    
    for (int i = 0; i < 3; i ++ ) sort(a[i] + 1, a[i] + n + 1);     // 二分
    
    ll res = 0;
    
    for (int i = 1; i <= n; i ++ )
    {
        int cnta = lower_bound(a[0] + 1, a[0] + n + 1, a[1][i]) - a[0] - 1;
        int cntc = n - (upper_bound(a[2] + 1, a[2] + n + 1, a[1][i]) - a[2]) + 1;
        
        res += (ll)cnta * cntc;
    }
    cout << res;
}

思路(双指针):

  • 对查找进一步优化,找排好序后a数组中小于key的个数可以用双指针算法,c数组同理
#include 
#include 
using namespace std;

typedef long long ll;

const int N = 1e5 + 10;

int n;
int a[3][N];

int main()
{
    cin >> n;
    for (int i = 0; i < 3; i ++ )
        for (int j = 1; j <= n; j ++ )
            cin >> a[i][j];
    
    for (int i = 0; i < 3; i ++ ) sort(a[i] + 1, a[i] + n + 1);     // 二分
    
    ll res = 0;
    
    int pa = 1, pc = 1;
    for (int i = 1; i <= n; i ++ )
    {
        int key = a[1][i];
        while (pa <= n && a[0][pa] < key) pa ++ ;       // >=
        while (pc <= n && a[2][pc] <= key) pc ++ ;      // >
        
        res += (ll)(pa - 1) * (n - pc + 1);
    }
    
    cout << res;
}

思路 (前缀和):

  • 每次都是找出a数组中小于b[i]的个数,因此可以预处理出这个个数
  • 首先记录a数组中每个值对应数量,由于元素值范围只有 1 0 5 10^5 105,因此直接用数组即可
  • 注意到这题元素值可能为0,因此整体偏移增加1,不影响相对大小
#include 
#include 
using namespace std;

typedef long long ll;

const int N = 1e5 + 10;

int n;
int cnta[N], b[N], cntc[N];

int main()
{
    cin >> n;
    for (int i = 1, x; i <= n && cin >> x; i ++ ) cnta[ ++ x] ++ ;
    for (int i = 1; i <= n && cin >> b[i]; i ++ ) b[i] ++ ;
    for (int i = 1, x; i <= n && cin >> x; i ++ ) cntc[ ++ x] ++ ;
    
//    cnta[0] = cnta[0];
    for (int i = 1; i < N; i ++ ) cnta[i] += cnta[i - 1];
//    cntc[0] = cntc[0];
    for (int i = 1; i < N; i ++ ) cntc[i] += cntc[i - 1];
    
    ll res = 0;
    for (int i = 1; i <= n; i ++ )
    {
        int key = b[i];
        
        res += (ll)cnta[key - 1] * (cntc[N - 1] - cntc[key]);
    }
    cout << res;
}

AcWing 1245. 特别数的和

小明对数位中含有 2、0、1、9 的数字很感兴趣(不包括前导 0),在 1 到 40 中这样的数包括 1、2、9、10 至 32、39 和 40,共 28 个,他们的和是 574。

请问,在 1 到 n 中,所有这样的数的和是多少?

输入格式
共一行,包含一个整数 n。

输出格式
共一行,包含一个整数,表示满足条件的数的和。

数据范围
1≤n≤10000
输入样例:
40
输出样例:
574

思路 :

  • 直接模拟,复杂度为 10000 ∗ 5 10000*5 100005
#include 
using namespace std;

int main()
{
    int n; cin >> n;
    
    int res = 0;
    
    for (int i = 1; i <= n; i ++ )
    {
        int x = i;
        while (x)
        {
            int t = x % 10;
            if (t == 2 || t == 0 || t == 1 || t == 9)
            {
                res += i; break;
            }
            x /= 10;
        }
    }
    cout << res;
}

AcWing 1204. 错误票据

某涉密单位下发了某种票据,并要在年终全部收回。

每张票据有唯一的ID号。

全年所有票据的ID号是连续的,但ID的开始数码是随机选定的。

因为工作人员疏忽,在录入ID号的时候发生了一处错误,造成了某个ID断号,另外一个ID重号。

你的任务是通过编程,找出断号的ID和重号的ID。

假设断号不可能发生在最大和最小号。

输入格式
第一行包含整数 N,表示后面共有 N 行数据。

接下来 N 行,每行包含空格分开的若干个(不大于100个)正整数(不大于100000),每个整数代表一个ID号。

输出格式
要求程序输出1行,含两个整数 m,n,用空格分隔。

其中,m表示断号ID,n表示重号ID。

数据范围
1≤N≤100
输入样例:
2
5 6 8 11 9
10 12 9
输出样例:
7 9

思路 :

  • stringstream的用法
  • 第一个cin后记得还有一个换行符
  • 这里用>=2而不是!=1
#include 
#include 
#include 
using namespace std;

const int N = 1e6;

int n, a[N];

int main()
{
    int cnt; cin >> cnt;
    
    string line;
    getline(cin, line);
    
    while (cnt -- )
    {
        getline(cin, line);
        stringstream ssin(line);
        while (ssin >> a[n]) n ++ ;
    }
    
    sort(a, a + n);
    
    int res1, res2;
    for (int i = 1; i < n; i ++ )
    {
        if (a[i] - a[i - 1] >= 2) res1 = a[i] - 1;
        else if (a[i] == a[i - 1]) res2 = a[i];
    }
    cout << res1 << ' ' << res2;
}

AcWing 466. 回文日期

在日常生活中,通过年、月、日这三个要素可以表示出一个唯一确定的日期。

牛牛习惯用 8 位数字表示一个日期,其中,前 4 位代表年份,接下来 2 位代表月份,最后 2 位代表日期。

显然:一个日期只有一种表示方法,而两个不同的日期的表示方法不会相同。

牛牛认为,一个日期是回文的,当且仅当表示这个日期的 8 位数字是回文的。

现在,牛牛想知道:在他指定的两个日期之间(包含这两个日期本身),有多少个真实存在的日期是回文的。

一个 8 位数字是回文的,当且仅当对于所有的 i(1≤i≤8) 从左向右数的第 i 个数字和第 9−i 个数字(即从右向左数的第 i 个数字)是相同的。

例如:

对于 2016 年 11 月 19 日,用 8 位数字 20161119 表示,它不是回文的。
对于 2010 年 1 月 2 日,用 8 位数字 20100102 表示,它是回文的。
对于 2010 年 10 月 2 日,用 8 位数字 20101002 表示,它不是回文的。
输入格式
输入包括两行,每行包括一个 8 位数字。

第一行表示牛牛指定的起始日期 date1,第二行表示牛牛指定的终止日期 date2。保证 date1 和 date2 都是真实存在的日期,且年份部分一定为 4 位数字,且首位数字不为 0。

保证 date1 一定不晚于 date2。

输出格式
输出共一行,包含一个整数,表示在 date1 和 date2 之间,有多少个日期是回文的。

输入样例:
20110101
20111231
输出样例:
1

思路 :

  • 枚举所有date1到date2之间的8位数字需要 8 10 8^{10} 810,大于 1 0 9 10^9 109,所以不行
  • 考虑到我们需要统计的是 回文数的数量, 因此,干脆枚举出所有的8位数 回文数,也就是枚举出这个8位回文数的前4位,自然可以得到这个回文数,判断是否满足条件,这样,我们枚举只需要 4 10 = ( 2 10 ) 2 = 1 0 6 4^{10}=(2^{10})^2=10^6 410=(210)2=106
  • 回文数需要满足的条件 :1.在date1和2的范围内1;2.符合日期要求(其中要判断闰年)
  • 关于闰年 :闰年就是二月有29天,而平年的二月只有28天
  • 如何判断闰年 :(year % 400 == 0) || (year % 4 == 0 && year % 100 != 0)),则为闰年,也就是说要么整除400,要么整除4且不整除100
  • 注意由4位数得到回文数的时候里面一定要嵌套一个四次的循环,否则得到的不一定是8位数
#include 
using namespace std;

int months[13] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};

bool check(int n)
{
    int year = n / 10000;
    int month = n / 100 % 100;
    int day = n % 100;
    
    if (!(month >= 1 && month <= 12)) return false;
    
    if (!day) return false;
    
    if (month == 2)
    {
        bool leap = false;
        if ((year % 400 == 0) || (year % 4 == 0 && year % 100 != 0)) leap = true;
        if (leap && day > 29) return false;
        if (!leap && day > 28) return false;
    }
    else if (day > months[month]) return false;
    
    return true;
}

int main()
{
    int date1, date2; cin >> date1 >> date2;
    
    int res = 0;
    
    for (int i = 1000; i <= 9999; i ++ )
    {
        int date = i, x = i;
        for (int j = 0; j < 4; j ++ ) date = date * 10 + x % 10, x /= 10;
        if (date >= date1 && date <= date2 && check(date)) res ++ ;
    }
    cout << res;
}

AcWing 787. 归并排序

给定你一个长度为 n 的整数数列。

请你使用归并排序对这个数列按照从小到大进行排序。

并将排好序的数列按顺序输出。

输入格式
输入共两行,第一行包含整数 n。

第二行包含 n 个整数(所有整数均在 1∼109 范围内),表示整个数列。

输出格式
输出共一行,包含 n 个整数,表示排好序的数列。

数据范围
1≤n≤100000
输入样例:
5
3 1 2 4 5
输出样例:
1 2 3 4 5

思路 :

  • 归并属于分治算法,有三个步骤
  • 1.递归的终止情况
  • 2.递归处理两个子问题
  • 3.合并两个子问题
#include 
using namespace std;

const int N = 1e5 + 10;

int n;
int q[N], w[N];

void merge_sort(int l, int r)
{
    if (l >= r) return ;
    
    int mid = l + r >> 1;
    merge_sort(l, mid), merge_sort(mid + 1, r);
    
    int i = l, j = mid + 1, k = 0;
    while (i <= mid && j <= r)
    {
        if (q[i] < q[j]) w[k ++ ] = q[i ++ ];
        else w[k ++ ] = q[j ++ ];
    }
    while (i <= mid) w[k ++ ] = q[i ++ ];
    while (j <= r) w[k ++ ] = q[j ++ ];
    
    for (i = l, j = 0; i <= r; i ++ , j ++ ) q[i] = w[j];
}

int main()
{
    cin >> n;
    for (int i = 1; i <= n && cin >> q[i]; i ++ );
    
    merge_sort(1, n);
    
    for (int i = 1; i <= n; i ++ ) cout << q[i] << ' ';
}

习题

AcWing 1219. 移动距离

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

思路 :

  • 每行w个,组间递增,组内递增或递减,找给定数在第几组和第几个位置
  • 注意到我们应该从第0行开始而不是第1行(因为/出来第1行实际得到第0行),所以第0行和第0列,且楼号从1开始,所以输入进来的楼号-1
  • 偶数行(因为从第0行开始,因此是&1)处理方法,单纯就是倒置,可以直接根据简单公式进行转换
#include 
using namespace std;

int main()
{
    int w, m, n; cin >> w >> m >> n;
    
    m -- , n -- ;
    
    int x1 = m / w, y1 = m % w;
    int x2 = n / w, y2 = n % w;
    
    if (x1 & 1) y1 = w - y1 - 1;
    if (x2 & 1) y2 = w - y2 - 1;
    
    cout << abs(x1 - x2) + abs(y1 - y2);        //曼哈顿距离
}

AcWing 1229. 日期问题

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

小明知道这些日期都在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

思路 :

  • 首先枚举出所有范围内的日期19600101到20591231
  • 判断是否满足是三个日期之一,且是否是有效的日期
#include 
using namespace std;

int months[13] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};

bool check(int date)
{
    int year = date / 10000, month = date % 10000 / 100, day = date % 100;
    
    if (!(month >= 1 && month <= 12)) return false;
    if (!day) return false;
    
    if (month == 2)
    {
        bool leap = false;
        if ((year % 400 == 0) || (year % 4 == 0 && year % 100 != 0)) leap = true;
        if (leap && day > 29) return false;
        if (!leap && day > 28) return false;
    }
    else if (day > months[month]) return false;
    return true;
}

int main()
{
    int a, b, c; scanf("%d/%d/%d", &a, &b, &c);
    
    for (int date = 19600101; date <= 20591231; date ++ )
    {
        int year = date / 10000, month = date % 10000 / 100, day = date % 100;
        
        if (!check(date)) continue;
        if ((year % 100 == a && month == b && day == c) ||
            (year % 100 == c && month == a && day == b) ||
            (year % 100 == c && month == b && day == a))
            printf("%d-%02d-%02d\n", year, month, day);
    }
}

AcWing 1231. 航班时间

小 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

思路 :

  • 将两次的飞行时间算出(用 表示)相加除以二 就是所求的飞行时间了,输出用标准格式
  • 将c++字符串转换成纯c字符串 .c_str(),然后用到sscanf中
  • sscanf的用法
#include 
using namespace std;

int get_time()
{
    string line;
    getline(cin, line);
    
    if (line.back() != ')') line += " (+0)";
    
    int h1, m1, s1, h2, m2, s2, d;
    sscanf(line.c_str(), "%d:%d:%d %d:%d:%d (+%d)", &h1, &m1, &s1, &h2, &m2, &s2, &d);
    
    return h2 * 3600 + d * 24 * 3600 - h1 * 3600 + m2 * 60 - m1 * 60 + s2 - s1;
}

int main()
{
    int _; cin >> _;
    
    string line;
    getline(cin, line);
    
    while (_ -- )
    {
        int time1 = get_time(), time2 = get_time();
        int time = (time1 + time2) / 2;
        printf("%02d:%02d:%02d\n", time / 3600, time % 3600 / 60, time % 60);
    }
}

AcWing 1241. 外卖店优先级

“饱了么”外卖系统中维护着 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 号) 在优先缓存中。

思路 :

  • 时间顺序处理所有订单
  • 每个订单包括两个信息 :订单发生的时刻,订单所属店家
  • 因此,处理当前订单时,首先根据该店家的上一个订单的时刻计算出当前的优先级,然后再加上当前的优先级
  • st数组表示该店家是否在名单内;last数组表示该店家上一个订单的时刻
  • 处理完所有订单后,还要处理在T时刻时所有商家的状态,动态维护st数组
#include 
#include 
using namespace std;

const int N = 1e5 + 10;

typedef pair<int, int> PII;

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

int main()
{
    cin >> n >> m >> t;
    
    for (int i = 0, ts, id; i < m && cin >> ts >> id; i ++ ) order[i] = {ts, id};
    
    sort(order, order + m);
    
    for (int i = 0; i < m; )	// 不能顺序枚举,因为这里是根据与上个时刻之间没有订单的数量来变化的
    {
        int j = i;
        while (j < m && order[j] == order[i]) j ++ ;
        
        int ts = order[i].first, id = order[i].second, cnt = j - i;
        
        i = j;		// 变化i
        
        score[id] -= (ts - last[id] - 1);		// 之间的数量,而非包含某个端点
        if (score[id] < 0) score[id] = 0;
        if (score[id] <= 3) st[id] = false;
        
        score[id] += cnt * 2;
        if (score[id] > 5) st[id] = true;
        
        last[id] = ts;
    }
    
    for (int i = 1; i <= n; i ++ )
        if (last[i] < t)
        {
            score[i] -= (t - last[i]);		// 已知t时刻没有订单,因此包含一个端点
            if (score[i] <= 3) st[i] = false;
        }
    
    int res = 0;
    for (int i = 1; i <= n; i ++ ) res += st[i];
    
    cout << res;
}

AcWing 788. 逆序对的数量

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

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

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

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

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

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

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

思路 :

  • 利用 归并排序 求逆序对的思路 :
  • 逆序对有三种 :两个数都在左子问题,两个数都在右子问题,一左一右;其中,前两种在递归处理两个子问题时已经累加,因此,只需要在合并两个子问题时统计第三种逆序对的数量
#include 
using namespace std;

typedef long long ll;

const int N = 1e5 + 10;

int n, q[N], w[N];
ll res;

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

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

你可能感兴趣的:(c++,蓝桥杯,算法)