洛谷 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+50;

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=0;
    while(x > 0)
    {
        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+1,a+n+1,cmp);//离散化
    for(int i=1;i <= n;++i)
        a[i].newVal=i;//存储离散化后的值
    sort(a+1,a+n+1,cmp1);
    int res=1;
    for(int i=1;i <= n;++i)
    {
        Add(a[i].newVal);
        res=max(res,i-Sum(i));//询问每个位置，找到所需的最大的循环次数
    }
    printf("%d
",res);
}
int main()
{
    scanf("%d",&n);
    for(int i=1;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+50;

int n;
struct Data
{
    int v;
    int id;
    int newV;
}data[maxn];
struct BIT
{
    int bit[maxn];
    void Init()
    {
        memset(bit,0,sizeof(bit));
    }
    void add(int t)
    {
        while(t < maxn)
        {
            bit[t]++;
            t += lowbit(t);
        }
    }
    int Sum(int t)
    {
        int sum=0;
        while(t > 0)
        {
            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+1,data+n+1,cmp1);
    for(int i=1;i <= n;++i)
        data[i].newV=i;
    sort(data+1,data+n+1,cmp2);

    _bit.Init();
    int ans=1;
    for(int i=1;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=1;i <= n;++i)
    {
        scanf("%d",&data[i].v);
        data[i].id=i;
    }
    printf("%d
",Solve());

    return 0;
}