洛谷 P4378 [USACO18OPEN]Out of Sorts S(树状数组求冒泡排序循环次数)

传送门:Problem P4378

https://www.cnblogs.com/violet-acmer/p/9833502.html

　　要回宿舍休息了，题解明天再补吧。

题解：

　　定义一数组 a[maxn]
　　考察冒泡排序的本质。

　　冒泡排序，每次会把最大的数直接沉底，但是比较小的数，会往前面缓慢冒泡。

　　具体来说，如果一个数 val 在数组有序后的排名是 i ，但是目前位置在 i 之后，那么，每次循环，val 必然会往前面移动一位。

因为前面必然会有一个比 val 大的数往后沉。

　　swap的次数，就是逆序对数

　　循环的次数，就是max( i 前比a[i]大的数的个数)(i=1,2,3,......,n)

　　注意事项：

　　(1):首先需要做的是离散化原数组，因为 a[i] 的值最大可达 1e9，但 n 最大才 1e5，注意在排序的时候，对于值相同的两个数，初始编号小的在前。

　　(2):最终结果要额外 +1

AC代码：

 #include<iostream>
 #include<algorithm>
 #include<cstdio>
 using namespace std;
 #define lowbit(x) (x&(-x))
 const int maxn=1e5+;

 int N;
 struct Node
 {
     int val;
     int id;//存储初始编号
     int newVal;//存储离散化后 val 对应的新值
 }a[maxn];
 //==============BIT===================
 int bit[maxn];
 void Add(int x)
 {
     while(x <= N)
     {
         bit[x]++;
         x += lowbit(x);
     }
 }
 int Sum(int x)
 {
     int sum=;
     while(x > )
     {
         sum += bit[x];
         x -= lowbit(x);
     }
     return sum;
 }
 //=====================================
 bool cmp(Node _a,Node _b){
     //值不同，值小的在前;值相同，初始编号小的在前，保证排序的稳定性
     return _a.val < _b.val || (_a.val == _b.val && _a.id < _b.id);
 }
 bool cmp1(Node _a,Node _b){
     return _a.id < _b.id;
 }
 void Solve()
 {
     sort(a+,a+N+,cmp);
     for(int i=;i <= N;++i)
         a[i].newVal=i;//离散化后的对应的值,虽然可能大小变了，但其对应的相对次序是不变的
     sort(a+,a+N+,cmp1);//恢复原数组对应的顺序
     int res=;
     for(int i=;i <= N;++i)
     {
         //Sum(a[i].newVal) : i 之前，数值不大于a[i].newVal 的个数
         //i-1-Sum(a[i].newVal) : i 之前，数值大于a[i].newVal的个数
         //而答案就是 max(i-1-Sum(a[i].newVal)
         res=max(res,i--Sum(a[i].newVal));
         Add(a[i].newVal);
     }
     printf("%d\n",res+);//最终结果要加1，因为不管当前交换完后是否有序，都需要额外输出一个 moo 来判断是否有序
 }
 int main()
 {
     scanf("%d",&N);
     for(int i=;i <= N;++i)
     {
         scanf("%d",&a[i].val);
         a[i].id=i;
     }
     Solve();
 }