【冒泡排序】树状数组 & 结论

题意是给你一个序列，通过某种规律生成，没有什么特别的规律【大概吧】，让你求经过多少轮冒泡排序它可以变成从小到大有序的。

按题意打暴力是30分，它还有个很妙的70分做法，用树状数组。求每个数左边有多少个比它大的数，左边比它大的数最多的那个个数就是需要冒泡排序的轮数。

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

const int MAXN = 1e6 + 5;

int n;
int C[MAXN];

int lowbit(int x)
{
    return x & (-x);
}

void update(int x, int v)
{
    for (; x <= n; x += lowbit(x))
    {
        C[x] += v;
    }
}

int query(int x)
{
    int res = 0;
    for (; x > 0; x -= lowbit(x))
    {
        res += C[x];
    }
    return res;
}

struct Node {
    int id, num;

    bool operator < (const Node &other) const
    {
        return num > other.num;
    }
} a[MAXN];

int main()
{
    freopen("bubble.in", "r", stdin);
    freopen("bubble.out", "w", stdout);
    scanf("%d", &n);
    long long S;
    cin >> S;
    int B, C, D;
    scanf("%d %d %d", &B, &C, &D);

    for (int i = 1; i <= n; i++)
    {
        a[i].num = i;
        a[i].id = i;
        S = (long long)((S % D * B % D) % D + C % D) % D;
        swap(a[i].num, a[(S % i) + 1].num);
    }

    sort(a + 1, a + n + 1);

    int k = 1;
    int Max = -1;
    for (int i = 1; i <= n; i++)
    {
        while (k <= n && a[k].num > a[i].num)
        {
            update(a[k].id, 1);
            k++;
        }
        Max = max(Max, query(a[i].id));
    }

    printf("%d\n", Max);
    fclose(stdin);
    fclose(stdout);
    return 0;
}

把每个数的位置和它的值分开。按照值的大小排一遍序，再遍历一遍，因为已经排好序了，比它大的数只会更多不会更少，只需要遍历一遍就可以。妙的地方就在于排序和id、num分开。
我本来是不会用树状数组维护它左边比它小的数的个数的，然后我看了HDU4417的题解学会的，这道题就是这个思想，抄的代码就不放了2333

100分做法是counter = max{i − A i }
这个式子即(i - 1)-(Ai - 1)，实际上他前面的数的个数减去比它小的数的个数，就也能得到它前面的比它大的数的个数的最大值。【这个证明一点也不严密(:з」∠)还是lyh小姐姐给我讲哒，炒鸡感谢毕竟我太笨了】

【一个花了一下午想了【自己还没想出来】第一题的70分做法的辣鸡(:з」∠)】