洛谷 P4375 [USACO18OPEN]Out of Sorts G(树状数组求冒泡排序循环次数加强版)

传送门

参考资料：

　　[1]:https://www.cnblogs.com/Miracevin/p/9662350.html

　　[2]:https://blog.csdn.net/lengxuenong/article/details/80482202?utm_source=blogxgwz1

　　今天已经理解了一晚上了，还是处于懵懵懂懂的状态，明天在肝一天，一定要将自己理解的题解写出来，哇咔咔！

•题解

　　定义数组 a；

　　先将含有 n 个元素的数组 a 离散化，则离散化后的 n 个元素对应 1~n 的某个排列，而我们所要求的就是将离散化后的排列变为 1,2,3,...,n 所需的循环次数。

　　对于位置 i ，在这个双向排序过程中，每次 while( ) 循环会把一个 i 之前的大于 i 的数移到 i 后面，并且把一个 i 之后小于 i 的数移到 i 的前面。

　　for : i  1 to N

　　　　我们可以对于所有的位置 i ，找到[1,i]范围内比 i 小的数的个数 s，i-s 就是 i 位置把小于 i 的放在 i 位置前面，大于 i 的放在 i 位置后面的循环次数。

•对红色字体的理解

　　冒泡排序，通过交换相邻两数最终使得数组有序；

　　对于每个位置 i ，如果比 i 大的数都交换到 i 位置之后，比 i 小的数都交换到 i 位置之前；

　　那么，等结束最后一个 i 位置的时候，冒泡排序也就结束了，此时数组也就是有序的。

　　因此，对于此题的双向循环，每次判断当前位置 i 需要通过多少次while( )循环才能使得：

　　比 i 大的数都交换到 i 位置之后，比 i 小的数都交换到 i 位置之前；

　　因此，只需要求出 [1,i] 位置上比 i 大的数的个数，输出最大的那个即是答案；

•Code

 #include<bits/stdc++.h>
 using namespace std;
 #define lowbit(x) (x&(-x))
 const int maxn=1e5+;

 int n;
 struct Node
 {
     int val;
     int id;
     int newVal;
 }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) {//注意，如果val相同，初始编号 id 小的在前
     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)
     {
         Add(a[i].newVal);
         res=max(res,i-Sum(i));//询问每个位置，找到所需的最大的循环次数
     }
     printf("%d\n",res);
 }
 int main()
 {
     scanf("%d",&n);
     for(int i=;i <= n;++i)
         scanf("%d",&a[i].val),a[i].id=i;
     Solve();
 }

•初始疑惑

　　将 i 之前的大于 i 的数归位，貌似只用到了问题中的第一个for( )，而并没有用第二个 for( )循环啊；

　　那为什么 i-s 就是 i 位置把小于 i 的放在 i 位置前面，大于 i 的放在 i 位置后面的循环次数呢？

我的理解：

　　①如果将 [1,i] 位置中的大于 i 的数全部移到 i 位置后，[i+1,n]位置中的数肯定全部大于 i；

　　如果 [i+1,n] 位置存在小于 i 的数，那，[1,i]中肯定存在大于 i 的数，不然，怎么交换呢？

　　这样的话，[1,i]位置中大于 i 的数就没有全部移到 i 位置后，与条件①矛盾；

　　所以条件①成立；

---

分割线：2019.7.17

•感想

　　当初理解了好长时间的东西到如今成了自然而然地事；

•Code

 #include<bits/stdc++.h>
 using namespace std;
 #define lowbit(x) (x&-x)
 const int maxn=1e5+;

 int n;
 struct Data
 {
     int v;
     int id;
     int newV;
 }data[maxn];
 struct BIT
 {
     int bit[maxn];
     void Init()
     {
         memset(bit,,sizeof(bit));
     }
     void add(int t)
     {
         while(t < maxn)
         {
             bit[t]++;
             t += lowbit(t);
         }
     }
     int Sum(int t)
     {
         int sum=;
         while(t > )
         {
             sum += bit[t];
             t -= lowbit(t);
         }
         return sum;
     }
 }_bit;

 ///树状数组求逆序对时，v相同的一定要让编号小的在前
 bool cmp1(Data a,Data b)
 {
     if(a.v != b.v)
         return a.v < b.v;
     return a.id < b.id;
 }
 bool cmp2(Data a,Data b)
 {
     return a.id < b.id;
 }
 int Solve()
 {
     sort(data+,data+n+,cmp1);
     for(int i=;i <= n;++i)
         data[i].newV=i;
     sort(data+,data+n+,cmp2);

     _bit.Init();
     int ans=;
     for(int i=;i <= n;++i)
     {
         _bit.add(data[i].newV);
         ans=max(ans,i-_bit.Sum(i));
     }

     return ans;
 }
 int main()
 {
 //    freopen("C:\\Users\\hyacinthLJP\\Desktop\\in&&out\\contest","r",stdin);
     scanf("%d",&n);
     for(int i=;i <= n;++i)
     {
         scanf("%d",&data[i].v);
         data[i].id=i;
     }
     printf("%d\n",Solve());

     return ;
 }