逆序对的数量+超快速排序+车厢重组

一、#逆序对的数量

##题目描述

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

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

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

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

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

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

解析：

首先我们给出逆序对的定义：

对于数列的第 i 个和第 j 个元素，如果满足 i < j 且 a[i] > a[j]，则其为一个逆序对。重要的地方在于，一个元素可以不只是在一个逆序对中存在。如果 k > j > i 且 a[i] > a[j] > a[k]，那么这里有两个含 a[i] 的逆序对，分别是 (a[i], a[j]) 和 (a[i], a[k]), a[i]是可以使用多次的。

那么第二步是分析问题，这里我们可以使用分治法解决问题。

我们将序列从中间分开，将逆序对分成三类：

1.两个元素都在左边；2.两个元素都在右边；3.两个元素一个在左一个在右.

计算逆序对的数量（序列）：
1. 递归算左边的；2. 递归算右边的；3. 算一个左一个右的.
再把它们加到到一起。

这个时候我们注意到一个很重要的性质，左右半边的元素在各自任意调换顺序，是不影响第三步计数的，因此我们可以数完就给它排序。这么做的好处在于，如果序列是有序的，会让第三步计数很容易。所以我们使用归并排序。

#include <bits/stdc++.h>
using namespace std;
const int N=1e6+10;
#define int long long
int a[N],tmp[N];
int cnt;
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 k=0,i=l,j=mid+1;
    while (i<=mid&&j<=r)
    {
        if (a[i]<=a[j]) tmp[k++]=a[i++];
        else
        {
            tmp[k++]=a[j++];
            cnt +=mid-i+1;
        }
    }
    while (i<=mid) tmp[k++]=a[i++];
    while (j<=r)   tmp[k++]=a[j++];
    for (int i=l,j=0;i<=r;i++,j++) a[i]=tmp[j];
}
signed main()
{
    int n;
    cin>>n;
    for (int i=0;i<n;i++) cin>>a[i];
    merge_sort(0,n-1);
    cout<<cnt;
    return 0;
}

更新一下，逆序对还可以用离散化+树状数组 

#include <bits/stdc++.h>
using namespace std;
#define int long long
#define endl '\n'
#define ios ios::sync_with_stdio(false),cin.tie(0),cout.tie(0);
typedef pair<int,int> PII;
const double PI=acos(-1.0);
const int N=2e6+10;
int n;
int tr[N];
int lowbit(int x)
{
    return x&-x;
}
void add(int x,int c)
{
    for (int i=x;i<=n;i +=lowbit(i)) tr[i] +=c;
}
int query(int x)
{
    int ans=0;
    for (int i=x;i>0;i -=lowbit(i)) ans +=tr[i];
    return ans;
}
int a[N];
map <int,int> s;
void solve()
{
    cin>>n;
    for (int i=1;i<=n;i++) 
    {
        cin>>a[i];
        s[a[i]]=1;
    }
    int cnt=0;
    for (auto &[x,y]:s)
    {
        y=++cnt;
    }
    int ans=0;
    for (int i=1;i<=n;i++)
    {
        int x=s[a[i]];
        ans +=query(n)-query(x);
        add(x,1);
    }
    cout<<ans;
}
signed main()
{
    ios;
    int T=1;
    //cin>>T;
    while (T--) solve();
    return 0;
}

二、#超快速排序
##题目描述
在这个问题中，您必须分析特定的排序算法——超快速排序。
该算法通过交换两个相邻的序列元素来处理 n 个不同整数的序列，直到序列按升序排序。
对于输入序列 9 1 0 5 4，超快速排序生成输出 0 1 4 5 9。
您的任务是确定超快速排序需要执行多少交换操作才能对给定的输入序列进行排序。

输入格式
输入包括一些测试用例。
每个测试用例的第一行输入整数 n，代表该用例中输入序列的长度。
接下来 n 行每行输入一个整数 ai,代表用例中输入序列的具体数据，第 i 行的数据代表序列中第 i 数。
当输入用例中包含的输入序列长度为 0 时，输入终止，该序列无需处理。
输出格式
对于每个需要处理的输入序列，输出一个整数 op，代表对给定输入序列进行排序所需的最小交换操作数，每个整数占一行。

数据范围
0≤n<500000,一个测试点中，所有 n 的和不超过 500000，0≤ai≤999999999。

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

解析：

只通过比较和交换相邻两数数值的排序方法，显而易见就是冒泡排序。在排序过程中每找到一对大小颠倒的相邻数值，交换，就会使整个序列的逆序对少1个。最终排好序的序列逆序对个数显然为0，所以对a进行冒泡排序需要的最少交换次数就是序列a中逆序对的个数。我们直接用归并排序求出a的逆序对个数就是本题的答案。

与上述代码相同

#include <bits/stdc++.h>
using namespace std;
const int N=1e6+10;
#define int long long
int a[N],tmp[N];
int cnt;
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 k=0,i=l,j=mid+1;
    while (i<=mid&&j<=r)
    {
        if (a[i]<=a[j]) tmp[k++]=a[i++];
        else
        {
            tmp[k++]=a[j++];
            cnt +=mid-i+1;
        }
    }
    while (i<=mid) tmp[k++]=a[i++];
    while (j<=r)   tmp[k++]=a[j++];
    for (int i=l,j=0;i<=r;i++,j++) a[i]=tmp[j];
}
signed main()
{
    int n;
    cin>>n;
    for (int i=0;i<n;i++) cin>>a[i];
    merge_sort(0,n-1);
    cout<<cnt;
    return 0;
}

三、# 车厢重组

## 题目描述
在一个旧式的火车站旁边有一座桥，其桥面可以绕河中心的桥墩水平旋转。一个车站的职工发现桥的长度最多能容纳两节车厢，如果将桥旋转 180 度，则可以把相邻两节车厢的位置交换，用这种方法可以重新排列车厢的顺序。于是他就负责用这座桥将进站的车厢按车厢号从小到大排列。他退休后，火车站决定将这一工作自动化，其中一项重要的工作是编一个程序，输入初始的车厢顺序，计算最少用多少步就能将车厢排序。

## 输入格式共两行。  
第一行是车厢总数 N( <= 10000)。
第二行是 N 个不同的数表示初始的车厢顺序。

## 输出格式
一个整数，最少的旋转次数。

### 样例输入 #1
4
4 3 2 1
### 样例输出 #1
6

解析：

只通过比较和交换相邻两数数值的排序方法，显而易见就是冒泡排序。在排序过程中每找到一对大小颠倒的相邻的车厢号，交换，就会使整个序列的逆序对少1个。最终排好序的序列逆序对个数显然为0，所以对车厢号进行冒泡排序需要的最少交换次数就是车厢序列号中逆序对的个数。我们直接用归并排序求出车厢序列号的逆序对个数就是本题的答案。

与上述代码相同

#include <bits/stdc++.h>
using namespace std;
const int N=1e6+10;
#define int long long
int a[N],tmp[N];
int cnt;
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 k=0,i=l,j=mid+1;
    while (i<=mid&&j<=r)
    {
        if (a[i]<=a[j]) tmp[k++]=a[i++];
        else
        {
            tmp[k++]=a[j++];
            cnt +=mid-i+1;
        }
    }
    while (i<=mid) tmp[k++]=a[i++];
    while (j<=r)   tmp[k++]=a[j++];
    for (int i=l,j=0;i<=r;i++,j++) a[i]=tmp[j];
}
signed main()
{
    int n;
    cin>>n;
    for (int i=0;i<n;i++) cin>>a[i];
    merge_sort(0,n-1);
    cout<<cnt;
    return 0;
}