枚举，模拟与排序

（一）枚举与模拟

1.连号区间数

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

在 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

样例解释

第一个用例中，有 77 个连号区间分别是：[1,1],[1,2],[1,3],[1,4],[2,2],[3,3],[4,4][1,1],[1,2],[1,3],[1,4],[2,2],[3,3],[4,4]
第二个用例中，有 99 个连号区间分别是：[1,1],[1,2],[1,3],[1,4],[1,5],[2,2],[3,3],[4,4],[5,5]

解题思路：在连号区间里数字都是连在一起的，故而我们可以枚举每个区间，通过找出区间的最大值和最小值，进行相减，若结果等于区间的长度，则证明他们是连号区间，否则不是连号区间

代码：

#include<iostream>
#include<algorithm>
using namespace std;
int n,i,j,p[10010];
const int INF=1000000;
int main()
{
    cin>>n;
    for(i=0;i<n;i++)
    {
        cin>>p[i];
    }
    int ans=0;
    for(i=0;i<n;i++)
    {
         int maxv=-INF,minv=INF;
        for(j=i;j<n;j++)
        {
            maxv=max(maxv,p[j]);
            minv=min(minv,p[j]);
            if(maxv-minv==j-i)
                ans++;
        }
    }
    cout<<ans;
    return 0;
}

2.递增三元组

给定三个整数数组

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

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

1. 1≤i,j,k≤N
   
2. Ai<Bj<Ck
   

输入格式

第一行包含一个整数 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

解题思路：对于该题我们首先会想到，根据b来进行求解，对于b中的每一个数，我们找出a中所有小于它的个数，再从c中找出所有大于它的个数，两者相乘，再相加，就会算出总和，这样需要两重循环
然而n的数量级是105因此，两重循环会超时，因此我们需要另外像一种对策。
因此，我们可以通过前缀和的方法来找小于b和大于b的数，最后再利用数组记录小于b的个数和大于b的个数，小于b的个数可以通过ab[i]=s[b[i]-1]来统计，其中s数组是前缀和数组
大于b的个数可以通过：bc[i]=s[N-1]-s[b[i]];来进行统计，最后计算总和，这样就将O（n2）压缩成O（n），这样就大大减少了时间复杂度

代码：

#include<iostream>
#include<cstring>
using namespace std;
typedef long long ll;
const int N=100010;
ll a[N],b[N],c[N];
ll ab[N],bc[N];
ll s[N],cnt[N];
ll n,i,j,k;
int main()
{
    cin>>n;
    ll ans=0;
    for(i=0;i<n;i++)
    {
        cin>>a[i];
        a[i]++;//这里加1的目的是：防止数组b[i]-1出现负数
    }
    for(i=0;i<n;i++)
    {
         cin>>b[i];
         b[i]++;
    }
    for(i=0;i<n;i++)
    {
        cin>>c[i];
        c[i]++;
    }
    //计算a数组中小于b[i]的个数
    for(i=0;i<n;i++)
       cnt[a[i]]++;
    for(j=1;j<N;j++)
        s[j]=s[j-1]+cnt[j];
    for(i=0;i<n;i++)
        ab[i]=s[b[i]-1];

    memset(cnt,0,sizeof(cnt));
    memset(s,0,sizeof(s));
    for(i=0;i<n;i++)
       cnt[c[i]]++;
    for(j=1;j<N;j++)
        s[j]=s[j-1]+cnt[j];
    for(i=0;i<n;i++)
        bc[i]=s[N-1]-s[b[i]];

    for(i=0;i<n;i++)
        ans+=ab[i]*bc[i];
    cout<<ans;
    return 0;
}

3.特别数的和

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

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

输入格式

共一行，包含一个整数 n。

输出格式

共一行，包含一个整数，表示满足条件的数的和。

数据范围

1≤n≤10000

输入样例：

40

输出样例：

574

解题思路：这个比较简单，只需要模拟1~n之间的数字，对数字的每一位判断是否含有2，0，1，9即可

#include<iostream>
using namespace std;
int n,i,j;
int a,b,c,d,e,t;
int ans,x;
int main()
{
    cin>>n;
    for(i=1;i<=n;i++)
    {
        t=i;
        while(t)
        {
            x=t%10;
            if(x==2||x==0||x==1||x==9)
            {
                ans+=i;
                break;
            }
            t=t/10;
        }
    }
    cout<<ans;
    return 0;
}

4.错误票据

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

每张票据有唯一的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 对象流将string类型转换成数组类型，其次就是寻找断ID和重复ID
代码：

#include<iostream>
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<sstream>
using namespace std;
int n,i,j,k;
int ans1,ans2;
int q[10005];
int main()
{
    ans1=0,ans2=0;
    cin>>n;
    string line;
    getchar();
    i=0;
    while(n--)
    {
        getline(cin,line);
        stringstream ssin(line);
        while(ssin>>q[i])
            i++;
    }
    sort(q,q+i);
    for(j=1;j<i;j++)
    {
        if(q[j-1]+1!=q[j]&&q[j-1]!=q[j])
            ans1=q[j-1]+1;
        else if(q[j-1]==q[j])
            ans2=q[j];
    }
    cout<<ans1<<" "<<ans2<<endl;
    return 0;
}

5.回文日期

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

牛牛习惯用 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

 解题思路：我们可以枚举从1000~9999的数字，然后拼接成回文串是8位数字的，然后只要满足他大于等于data1，并且小于等于data2，并且满足合理日期我们就ans++；

判断合理日期：首先对8位数进行年/月/日分离，建立月份数组，对于day==0||month==0||month>12返回false，对于不是2月的，day>months[month]返回false，对于二月的，判断年是否为闰年，然后对day>28+k则返回false，否则返回true；

代码：

#include<iostream>
using namespace std;

int ans;
int months[13]={0,31,28,31,30,31,30,31,31,30,31,30,31};
bool check(int num)
{
    int year=num/10000;
    int month=(num%10000)/100;
    int day=num%100;
    if(day==0||month==0||month>12)
        return false;
    if(month!=2)
    {
        if(day>months[month])
            return false;
    }
    else
    {
        int k=0;
        if((year%4==0&&year%100!=0)||year%400==0)
            k=1;
        if(day>28+k)
            return false;
    }
    return true;
}

int main()
{
    int data1,data2,i;
    cin>>data1>>data2;
    for(i=1000;i<=9999;i++)
    {
        int t=i,x=t;
        while(x)
        {
            t=t*10+x%10;
            x/=10;
        }
        if(t>=data1&&t<=data2&&check(t))
            ans++;
    }
    cout<<ans;
    return 0;
}

6.移动距离

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

解题思路：直接根据数字求他的x和y，首先思考奇数偶数行的不同，先找出行数，根据能否整除排号宽度来找出对应行数，根据行数奇偶来判断列数，
判断列数时：观察该数字对排号宽度是否整除，若是偶数行并且整除则y就为1，若是偶数行并且不整除则y=w-(m%w)+1;若是奇数行并且整除则y=w；若是奇数行并且不整除则y=m%w
代码：

#include<iostream>
#include<algorithm>
using namespace std;
int w,m,n;

int main()
{
    int i,j;
    cin>>w>>m>>n;
    int x1,y1,x2,y2;
    //处理第一组数据
    if(m%w!=0)
    {
        x1=m/w+1;
    }
    else
        x1=m/w;
        
    if(x1%2==0)
    {
        if(m%w!=0)
            y1=w-(m%w)+1;
        else
            y1=1;
    }
    else
    {
        if(m%w!=0)
            y1=m%w;
        else
            y1=w;
    }
    //处理第二组数据
    if(n%w!=0)
    {
        x2=n/w+1;
    }
    else
        x2=n/w;
        
    if(x2%2==0)
    {
        if(n%w!=0)
            y2=w-(n%w)+1;
        else
            y2=1;
    }
    else
    {
        if(n%w!=0)
            y2=n%w;
        else
            y2=w;
    }
    cout<<abs(x1-x2)+abs(y1-y2);
    return 0;
}

7.日期问题

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

小明知道这些日期都在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<iostream>
#include<cstdio>
using namespace std;
int months[13]={0,31,28,31,30,31,30,31,31,30,31,30,31};

bool check(int year,int month,int day)
{
    if(day==0||month==0||month>12)
        return false;
    if(month!=2&&day>months[month])
        return false;
    if(month==2)
    {
        int k=0;
        if((year%4==0&&year%100!=0)||year%400==0)
            k=1;
        if(day>28+k)
            return false;
    }
    return true;
}

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

8.航班时间

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

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

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

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

由于北京和美国东部有 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，表示飞行时间为h小时m分s秒。

注意，当时间为一位数时，要补齐前导零，如三小时四分五秒应写为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

解题思路：飞机的飞行时间=（第一行的时间差+时差+第二行的时间差-时差）/2=（第一行的时间差+第二行的时间差）/2
因此我们要求的就是两行的时间差，换算成秒来进行计算，再有就是对读入的考虑，我们可以整合成一个格式，例如对于没有（）的我们可以对
他进行（+0）操作，这样格式都一样，我们能用sscanf来进行取数操作。计算时差
代码：

#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;

int cal_time(int h,int m,int s)
{
    return h*3600+m*60+s;
}
int get_time()
{
    string line;
    getline(cin,line);
    if(line[line.size()-1]!=')')
        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 cal_time(h2,m2,s2)-cal_time(h1,m1,s1)+d*24*3600;
}

int main()
{
    int n,i;
    cin>>n;
    getchar();
    while(n--)
    {
        int k=(get_time()+get_time())/2;
        int hour=k/3600,minute=(k%3600)/60,second=k%60;
        printf("%02d:%02d:%02d
",hour,minute,second);
    }
    return 0;
}

（二）排序
1.归并排序

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

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

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

输入格式

输入共两行，第一行包含整数 n。

第二行包含 n 个整数（所有整数均在1~109范围内），表示整个数列。

输出格式

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

数据范围

1≤n≤100000

输入样例：

5
3 1 2 4 5

输出样例：

1 2 3 4 5

解题思路：根据归并排序的思路做题
代码：

#include<iostream>
using namespace std;
const int N=100010;
void merge_sort(int q[],int l,int r)
{
    if(l>=r)
        return ;
    int mid=l+r>>1;
    int t[N];
    merge_sort(q,l,mid),merge_sort(q,mid+1,r);
    int i=l,j=mid+1,k=0;
    while(i<=mid&&j<=r)
    {
        if(q[i]<q[j])
        {
            t[k++]=q[i++];
        }
        else
        {
            t[k++]=q[j++];
        }
    }
    while(i<=mid)
        t[k++]=q[i++];
    while(j<=r)
        t[k++]=q[j++];
    for(i=l,j=0;i<=r;i++,j++)
        q[i]=t[j];
}

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

2.外卖店优先级

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

解题思路：对于这个问题，我们可以采取只统计他有订单的时刻，上一个订单与本次订单的时间差就是要减去的优先级，同时加上本次时刻的订单个数*2，然后判断该
号店能不能存在缓存区中，因此我们采用先排序，用sort，现根据时间排序，再根据店铺序号排序，来进行一家一家的统计。
代码：

#include<iostream>
#include<algorithm>
using namespace std;
#define x first
#define y second
typedef pair<int,int> PII;
const int N=100010;
int n,M,T,ts,id,ans,i,j;
int score[N],state[N],last[N];

PII order[N];
int main()
{
    cin>>n>>M>>T;
    for(i=0;i<M;i++)
        cin>>order[i].x>>order[i].y;
    sort(order,order+M);
    for(i=0;i<M;)
    {
        j=i;
        while(j<M&&order[j]==order[i])
            j++;
        int t=order[i].x,id=order[i].y,cnt=j-i;
        i=j;
        score[id]-=t-last[id]-1;
        if(score[id]<0)
        {
            score[id]=0;
            state[id]=false;
        }
        if(score[id]<=3)
        {
            state[id]=false;
        }
        //t时刻之前的处理
        score[id]+=cnt*2;
        if(score[id]>5)
            state[id]=true;
        last[id]=t;
    }
    for(i=1;i<=n;i++)
    {
        if(last[i]<T)
        {
            score[i]-=T-last[i];
            if(score[i]<=3)
                state[i]=false;
        }
    }
    for(i=1;i<=n;i++)
    {
        if(state[i])
            ans++;
    }
    cout<<ans;
    return 0;
}

3.逆序对的数量

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

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

输入格式

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

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

输出格式

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

数据范围

1≤n≤100000

输入样例：

6
2 3 4 5 6 1

输出样例：

5

 解题思路：这道题就是在归并的算法上进行一些小小的添加，好比一共两个区间，按从小到大排列好，对于后面区间的每个数来说，只要找出前面的第一个大于他的数即可，即可求出它的逆序对数：mid-（i-1）；因为第一个大于他的数，后面的肯定大于它，故而用前面区间的总数-（它的下标-1）。

代码：

#include<iostream>
using namespace std;
const int N=1e6+10;
long long ans;
void merge_sort(int q[],int l,int r)
{
    if(l>=r)
        return;
    int mid=l+r>>1;
    int t[N];
    merge_sort(q,l,mid),merge_sort(q,mid+1,r);
    int i=l,j=mid+1,k=0;
    while(i<=mid&&j<=r)
    {
        if(q[i]<=q[j])
            t[k++]=q[i++];
        else
        {
            ans+=mid-i+1;
            t[k++]=q[j++];
        }
    }
    while(i<=mid)
        t[k++]=q[i++];
    while(j<=r)
        t[k++]=q[j++];
    for(i=l,j=0;i<=r;i++,j++)
        q[i]=t[j];
}

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