枚举、模拟与排序

最新推荐文章于 2021-02-12 22:14:06 发布

幸愉聊信奥

最新推荐文章于 2021-02-12 22:14:06 发布

阅读量320

点赞数

分类专栏：蓝桥杯文章标签：枚举模拟排序

本文链接：https://blog.csdn.net/Edviv/article/details/107373221

版权

蓝桥杯专栏收录该内容

16 篇文章 1 订阅

订阅专栏

文章目录

连号区间数
递增三元组
特别数的和
错误票据
回文日期
归并排序
移动距离
日期问题
航班时间
外卖店优先级
逆序对的数量

连号区间数

题目大意
小明这些天一直在思考这样一个奇怪而有趣的问题：在 1∼N的某个排列中有多少个连号区间呢？这里所说的连号区间的定义是：如果区间 [L,R]里的所有元素（即此排列的第 L 个到第 R 个元素）递增排序后能得到一个长度 R−L+1
的“连续”数列，则称这个区间连号区间。当 N 很小的时候，小明可以很快地算出答案，但是当 N 变大的时候，问题就不是那么简单了，现在小明需要你的帮助。
输入格式
第一行是一个正整数 N，表示排列的规模。
第二行是 N 个不同的数字 P $_i$ ，表示这 N 个数字的某一排列。
输出格式
输出一个整数，表示不同连号区间的数目。
数据范围: 1≤N≤10000,1≤ $P_i$ ≤N
输入样例1:

4
3 2 4 1

输出样例1：

输入样例2：

5
3 4 2 5 1

输出样例2：

样例解释:
第一个用例中，有 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]
解题思路：
区间最大值 - 区间最小值 == 区间个数，就是一个连续区间

#include <cstdio>
#include <algorithm>
using namespace std;
const int maxn=1e4+7,INF=0x3f3f3f3f;
int a[maxn];
int main()
{
    int n;
    scanf("%d",&n);
    for(int i=0;i<n;++i) scanf("%d",&a[i]);
    int ans=0;
    for(int i=0;i<n;++i)
    {
        int maxx=-INF,minx=INF;
        for(int j=i;j<n;++j)
        {
            maxx=max(maxx,a[j]);
            minx=min(minx,a[j]);
            if(j-i == maxx-minx) ans++;
        }
    }
    printf("%d\n",ans);
    return 0;
}

递增三元组

题目大意
给定三个整数数组
$A$ =[ $A_1$ , $A_2$ ,… $A_N$ ],
$B$ =[ $B_1$ , $B_2$ ,… $B_N$ ],
$C$ =[ $C_1$ , $C_2$ ,… $C_N$ ],
请你统计有多少个三元组 (i,j,k) 满足：1≤i,j,k≤N， $A_i$ < $B_j$ < $C_k$
输入格式
第一行包含一个整数 N。
第二行包含 N 个整数 $A_1$ , $A_2$ ,… $A_N$ 。
第三行包含 N 个整数 $B_1$ , $B_2$ ,… $B_N$ 。
第四行包含 N 个整数 $C_1$ , $C_2$ ,… $C_N$ 。
输出格式
一个整数表示答案。
数据范围：1≤N≤10 $^5$ ,0≤ $A_i$ , $B_i$ , $C_i$ ≤ $10^5$
输入样例

输出样例

暴力思路:O(n $^3$ )

for(int i=0;i<n;++i)
    for(int j=0;j<n;++j)
        for(int k=0;k<n;++k)
            if(a[i]<b[j]&&b[j]<c[k]) res++;

优化：最多枚举一个数组 a[i]<b[j]<c[k]，对于每个 b[j]：
1.找a[i]中有多少个小于b[j]的数
2.找c[i]中有多少个大于b[j]的数

#include <cstdio>
#include <cstring>
using namespace std;
const int maxn=1e5+7;
typedef long long ll;
int a[maxn],b[maxn],c[maxn];
int ab[maxn],bc[maxn],cnt[maxn],s[maxn];
int main()
{
    int n;
    scanf("%d",&n);
    //每个数都自加 1,因为0≤a[i],b[i],c[i]≤1e5
    for(int i=1;i<=n;++i) scanf("%d",&a[i]),a[i]++;  
    for(int i=1;i<=n;++i) scanf("%d",&b[i]),b[i]++;
    for(int i=1;i<=n;++i) scanf("%d",&c[i]),c[i]++;
    //前缀和  ab[i]:表示集合a中比集合b中小的数
    for(int i=1;i<=n;++i) cnt[a[i]]++;
    for(int i=1;i<maxn;++i) s[i]+=s[i-1]+cnt[i];
    for(int i=1;i<=n;++i) ab[i]=s[b[i]-1];
    memset(cnt,0,sizeof cnt);
    memset(s,0,sizeof s);
    //前缀和  bc[i]:表示集合c中比集合b中大的数
    for(int i=1;i<=n;++i) cnt[c[i]]++;
    for(int i=1;i<=maxn;++i) s[i]+=s[i-1]+cnt[i];
    for(int i=1;i<=n;++i) bc[i]=s[maxn]-s[b[i]];
    //求三元组数
    ll res=0;
    for(int i=1;i<=n;++i) res+=(ll)ab[i]*bc[i];
    printf("%lld\n",res);
    return 0;
}

二分

#include <cstdio>
#include <algorithm>
#include <cstring>
using namespace std;
typedef long long ll;
int n;
const int maxn=1e5+7;
ll a[maxn],b[maxn],c[maxn];
//查找[l,mid][mid+1,r]
ll find_max(ll x)
{
    if(c[n-1]<=x) return 0;
    ll l=0,r=n-1;
    while(l<r)
    {
        ll mid=(l+r)>>1;
        if(c[mid]>x)r=mid;
        else l=mid+1;
    }
    //这里返回大于等于x的最小值的下标,个数就是n-l
    return n-l;
}
//查找[l,mid-1][mid,r]
ll find_min(ll x)
{
    if(a[0]>=x) return 0;
    ll l=0,r=n-1;
    while(l<r)
    {
        ll mid=(l+r+1)>>1;
        if(a[mid]<x) l=mid;
        else r=mid-1;
    }
    return l+1;  //数组下标从 0 开始
}
int main()
{
    scanf("%d",&n);
    for(int i=0;i<n;++i) scanf("%d",&a[i]);
    for(int i=0;i<n;++i) scanf("%d",&b[i]);
    for(int i=0;i<n;++i) scanf("%d",&c[i]);
    sort(a,a+n),sort(c,c+n);
    ll res=0;
    for(int i=0;i<n;++i)
        res+=find_min(b[i])*find_max(b[i]);
    printf("%lld\n",res);
    return 0;
}

特别数的和

题目大意
小明对数位中含有 2、0、1、9的数字很感兴趣（不包括前导 0），在 1 到 40 中这样的数包括 1、2、9、10 至 32、39 和 40，共 28个，他们的和是
574。请问，在 1 到 n 中，所有这样的数的和是多少？
输入格式
共一行，包含一个整数 n。
输出格式
共一行，包含一个整数，表示满足条件的数的和。
数据范围：1≤n≤10000
输入样例

输出样例

暴力枚举区间的数，满足累加，否则跳过，最后输出结果。

#include <cstdio>
using namespace std;
bool work(int x)
{
    int t=x;
    while(t)
    {
        int st=t%10;
        if(st==2 || st==0 || st==9 || st==1) return true;
        t/=10;
    }
    return false;
}
int main()
{
    int n,res=0;
    scanf("%d",&n);
    for(int i=1;i<=n;++i)
        if(work(i)) res+=i;
    printf("%d\n",res);
    return 0;
}

错误票据

题目大意
某涉密单位下发了某种票据，并要在年终全部收回。每张票据有唯一的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

桶排序

#include <cstdio>
#include <iostream>
#include <algorithm>
#define INF 0x3f3f3f3f
using namespace std;
const int maxn=1e5+7;
int a[maxn];
int main()
{
    int t;
    scanf("%d",&t);
    int x,idx=0,tmax=-INF,tmin=INF;
    while(cin>>x) 
    {
        a[x]++;
        tmax=max(tmax,x);
        tmin=min(tmin,x);
    }
    int m,n;
    for(int i=tmin;i<=tmax;++i)
    {
        if(!a[i]) m=i;
        if(a[i]>1) n=i;
    }
    printf("%d %d\n",m,n);
    return 0;
}

sstream用法

#include <cstring>
#include <sstream>
#include <iostream>
#include <algorithm>
using namespace std;
const int maxn = 10010;
int n;
int a[maxn];
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]) res2 = a[i];  // 重号
        else if (a[i] >= a[i - 1] + 2) res1 = a[i] - 1; // 断号

    cout << res1 << ' ' << res2 << endl;
    return 0;
}

回文日期

题目大意
用 8 位数字表示一个日期，其中，前 4 位代表年份，接下来 2 位代表月份，最后 2 位代表日期。显然：一个日期只有一种表示方法，而两个不同的日期的表示方法不会相同。牛牛认为，一个日期是回文的，当且仅当表示这个日期的 $8$ 位数字是回文的。现在，牛牛想知道：在他指定的两个日期之间（包含这两个日期本身），有多少个真实存在的日期是回文的。一个 8 位数字是回文的，当且仅当对于所有的 i(1 $\leq$ i $\leq$ 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

输出样例

只需要枚举左边的部分，然后判断日期是否合法，最后判断那个年月日是否合法。

#include <iostream>
using namespace std;
int m[13]={0,31,28,31,30,31,30,31,31,30,31,30,31};
bool check(int x)
{
    int ty=x/10000;
    int tm=x%10000/100;
    int td=x%100;

    if(!tm||tm>13||!td) return false;
    if(tm!=2&&td>m[tm]) return false;
    if(tm==2)
    {
        int temp=0;
        if((ty%4==0 && ty%100)||(ty%400==0)) temp=m[2]+1;
        else temp=m[2];
        if(td>temp) return false;
    }
    return true;
}
int main()
{
    int d1,d2;
    cin>>d1>>d2;
    int res=0;
    for(int i=1000;i<10000;++i)
    {
        int x=i,t=i;
        for(int j=0;j<4;++j) t=t*10+x%10,x/=10;
        if(t>=d1&&t<=d2&&check(t)) res++;
    }
    cout<<res<<'\n';
    return 0;
}

归并排序

题目大意
给定你一个长度为n的整数数列。请你使用归并排序对这个数列按照从小到大进行排序。并将排好序的数列按顺序输出。
输入格式
输入共两行，第一行包含整数 n。
第二行包含 n 个整数（所有整数均在1~10 $^9$ 范围内），表示整个数列。
输出格式
输出共一行，包含 n 个整数，表示排好序的数列。
数据范围：1≤n≤100000
输入样例

5
3 1 2 4 5

输出样例

1 2 3 4 5

归并排序：基于分治思想
1.确定分界点: mid = ( l+r )/2;
2.递归排序 left , right
3.归并合二为一

#include <cstdio>
using namespace std;
const int maxn=1e5+7;
int a[maxn],t[maxn];
void merge_sort(int a[],int l,int r)
{
    if(l>=r) return;
    int mid=(l+r)>>1;
    merge_sort(a,l,mid),merge_sort(a,mid+1,r);
    int idx=0,i=l,j=mid+1;
    while(i<=mid&&j<=r)
        if(a[i]<a[j]) t[idx++]=a[i++];
        else t[idx++]=a[j++];
        
    while(j<=r) t[idx++]=a[j++];
    while(i<=mid) t[idx++]=a[i++];
    
    for (i = l, j = 0; i <= r; i ++, j ++ ) a[i] = t[j];
}
int main()
{
    int n;
    scanf("%d",&n);
    for(int i=0;i<n;++i) scanf(" %d",&a[i]);
    merge_sort(a,0,n-1);
    for(int i=0;i<n;++i) printf("%d ",a[i]);
    return 0;
}

移动距离

题目大意
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

输出样例

1.先让 m–,n–
2.然后求出行和列
3.判断行奇数行就翻转

#include <cstdio>
#include <cmath>
using namespace std;
int main()
{
    int w,m,n;
    scanf(" %d%d%d",&w,&m,&n);
    --m,--n;
    int x=m/w,y=m%w;
    int xx=n/w,yy=n%w;
    if(x&1) y=w-y-1;
    if(xx&1) yy=w-yy-1;
    int res=abs(x-xx)+abs(y-yy);
    printf("%d\n",res);
    return 0;
}

日期问题

题目大意
小明正在整理一批历史文献。这些历史文献中出现了很多日期。小明知道这些日期都在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 <cstdio>
using namespace std;
int ms[13]={0,31,28,31,30,31,30,31,31,30,31,30,31};
bool check(int x,int y,int z)
{
    if(!y || y>13 || !z) return false;
    if(y!=2&&z>ms[y]) return false;
    if(y==2)
    {
        int t=0;
        if(!(x%400) ||(!(x%4)&&x%100)) t=ms[2]+1;  //判断闰年
        else t=ms[2];
        if(z>t) return false;
    }
    return true;
}
int main()
{
    int a,b,c;
    scanf("%d/%d/%d", &a, &b, &c);
    for(int i=19600101;i<=20591231;++i)
    {
        int y=i/10000,m=i%10000/100,d=i%100;
        if(check(y,m,d))
        {
             if (y % 100 == a && m == b && d == c ||        // 年/月/日
                m == a && d == b && y % 100 == c ||        // 月/日/年
                d == a && m == b &&y % 100 == c)           // 日/月/年
                printf("%d-%02d-%02d\n", y, m, d);
        }
    }
    return 0;
}

航班时间

题目大意
小 h 前往美国参加了蓝桥杯国际赛。小 h 的女朋友发现小 h 上午十点出发，上午十二点到达美国，于是感叹到“现在飞机飞得真快，两小时就能到美国了”。小 h 对超音速飞行感到十分恐惧。仔细观察后发现飞机的起降时间都是当地时间。由于北京和美国东部有 12 小时时差，故飞机总共需要 14 小时的飞行时间。不久后小 h 的女朋友去中东交换。小 h 并不知道中东与北京的时差。但是小 h 得到了女朋友来回航班的起降时间。小 h 想知道女朋友的航班飞行时间是多少。对于一个可能跨时区的航班，给定来回程的起降时间。假设飞机来回飞行时间相同，求飞机的飞行时间。
输入格式
一个输入包含多组数据。
输入第一行为一个正整数 T，表示输入数据组数。
每组数据包含两行，第一行为去程的起降时间，第二行为回程的起降时间。
起降时间的格式如下:

1.h1:m1:s1 h2:m2:s2
2.h1:m1:s1 h3:m3:s3 (+1)
3.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 <cstdio>
using namespace std;
int get_time()
{
    int x,y,z,xx,yy,zz,d=0;
    scanf("%d:%d:%d %d:%d:%d (+%d)",&x,&y,&z,&xx,&yy,&zz,&d);
    return (d*24*3600+(xx-x)*3600+(yy-y)*60+zz-z);
}
int main()
{
    int t;
    scanf(" %d",&t);
    while(t--)
    {
        int ans=(get_time()+get_time())/2;
        int h=ans/3600,m=ans%3600/60,s=ans%60;
        printf("%02d:%02d:%02d\n",h,m,s);
    }
    return 0;
}

c.str 及stl版本

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;

int get_seconds(int h, int m, int s)
{
    return h * 3600 + m * 60 + s;
}

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 get_seconds(h2, m2, s2) - get_seconds(h1, m1, s1) + d * 24 * 3600;
}

int main()
{
    int n;
    scanf("%d", &n);
    string line;
    getline(cin, line);     // 忽略掉第一行的回车
    while (n -- )
    {
        int time = (get_time() + get_time()) / 2;
        int hour = time / 3600, minute = time % 3600 / 60, second = time % 60;
        printf("%02d:%02d:%02d\n", hour, minute, second);
    }

    return 0;
}

外卖店优先级

题目大意
饱了么”外卖系统中维护着 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≤10 $^5$ ,
1≤ts≤T,
1≤id≤N
输入样例

输出样例

样例解释
6 时刻时，1 号店优先级降到 3，被移除出优先缓存；2 号店优先级升到 6，加入优先缓存。所以是有 1 家店 (2 号) 在优先缓存中。

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#define x first
#define y second
using namespace std;
typedef pair<int, int> PII;
const int N = 100010;
int n, m, T;
int score[N];   //表示第 i 个店铺当前得优先级
int last[N];    //表示第 i 个店铺上一次又订单的时刻
bool st[N];    //表示第 i 个店铺当前是否处于优先缓存中
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[j] == order[i]) j ++ ;   //处理重复的时间 和 id
        int t = order[i].x, id = order[i].y, cnt = j - i;   //cnt记录订单数
        i = j;

        score[id] -= (t - last[id] - 1);  //区间内的数
        
        if (score[id] < 0) score[id] = 0;
        if (score[id] <= 3) st[id] = false; // 以上处理的是t时刻之前的信息

        score[id] += cnt * 2;
        if (score[id] > 5) st[id] = true;
        
        last[id] = t;
    }

    for (int i = 1; i <= n; i ++ )
        if (last[i] < T)
        {
            score[i] -= (T - last[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 个元素，如果满足 i < j 且 a[i] > a[j]，则其为一个逆序对；否则不是。
输入格式
第一行包含整数n，表示数列的长度。
第二行包含 n 个整数，表示整个数列。
输出格式
输出一个整数，表示逆序对的个数。
数据范围：1≤n≤100000
输入样例

6
2 3 4 5 6 1

输出样例

设 A 为一个有 n 个数字的有序集 (n>1)，其中所有数字各不相同。
如果存在正整数 i, j 使得 1 ≤ i < j ≤ n 而且 A[i] > A[j]，则 <A[i], A[j]> 这个有序对称为 A 的一个逆序对，也称作逆序数

#include <iostream>
#include <cstdio>
#define ll long long 
const int N = 1e5 + 7;
using namespace std;
int a[N],tmp[N];
ll merge_sort(int a[], ll l, ll r)
{
    if(l >= r) return 0;
    
    ll mid = (l + r) >> 1;
    
    ll res = merge_sort(a, l, mid) + merge_sort(a, mid + 1, r);
    
    ll i = l, j = mid + 1, k = 0;
    while(i <= mid && j <= r)
        if(a[i] <= a[j]) tmp[k ++] = a[i ++];
        else 
        {
            res += mid - i + 1;
            tmp[k ++] = a[j ++];
        }
    while(i <= mid) tmp[k ++] = a[i ++];
    while(j <= r) tmp[k ++] = a[j ++];
    
    for(i = l, j = 0; i <= r; i++, j++) a[i] = tmp[j];
    return res;
}
int main()
{
    int n;
    scanf("%d",&n);
    for(int i = 0; i < n; i++) scanf("%d",&a[i]);
    n--;
    cout<<merge_sort(a,0,n)<<endl;
    return 0;
}

幸愉聊信奥

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
0
评论
枚举、模拟与排序

文章目录连号区间数递增三元组特别数的和错误票据连号区间数连号区间数题目大意小明这些天一直在思考这样一个奇怪而有趣的问题：在 1∼N的某个排列中有多少个连号区间呢？这里所说的连号区间的定义是：如果区间 [L,R]里的所有元素（即此排列的第 L 个到第 R 个元素）递增排序后能得到一个长度 R−L+1的“连续”数列，则称这个区间连号区间。当 N 很小的时候，小明可以很快地算出答案，但是当 N 变大的时候，问题就不是那么简单了，现在小明需要你的帮助。输入格式第一行是一个正整数 N，表示排列的规模。
复制链接

扫一扫