P6186 冒泡排序(树状数组 + 思维)

1.冒泡排序每一轮的交换次数等于n - x,x是满足以下条件的数的个数:这个数的前面没有比他大的数.我们称这个数在当前一轮冒泡排序不参与交换.

2.冒泡排序的交换的总轮数就是逆序对的总数量.

3.每一轮交换都会使得每一个数左边比他大的数的数量减少1, 直到为0.

4.对于一个数,如果前面有 x 个数比他大, 那么这个数就会在x + 1轮进行交换.

接下来, 我们只要用总的逆序对的数量减去前k轮减掉的逆序对就可以得到第k轮后的逆序对的数量了,我们可以使用树状数组维护差分的前缀和,具体来说,就是:第一个位置存的是逆序对的总数量, 后面第i + 1个位置就是第 i 轮存的减少的逆序对数量(即n - x_i).

最后,我们只需考虑交换:

我们令b数组为每个数之前比他大的数的个数

如果a[x] < a[x + 1], 那么就交换a[x] 和 a[x + 1],并交换b[x] 和 b[x + 1],令b[x + 1]加1,然后我们考虑这个交换对逆序对的数量的影响,这个操作会使得第1 ~ b[x + 1]轮的逆序对加1,使得总逆序对的数量加1.

如果a[x] > a[x + 1], 那么就交换a[x] 和 a[x + 1],并交换b[x] 和 b[x + 1],令b[x]减1,然后我们考虑这个交换对逆序对的数量的影响,这个操作会使得第1 ~ b[x]轮的逆序对减1,使得总逆序对的数量减1.

代码实现如下:

#include <iostream>
#include <algorithm>
#include <queue>
#include <cstring>
#include <cstdio>
#include <cmath>
#include <map>
#include <unordered_map>
#include <vector>
#include <stack>
#include <time.h>
#include <set>
#define IOS ios::sync_with_stdio(false), cin.tie(0)
#define int long long
#define PII pair<int, int>
#define PDI pair<double, int>
#define ll long long
#define ull unsigned long long
#define eps 1e-8
// #define MOD 1000000007
#define debug(a) cout << #a << "=" << a << endl;
#define all(x) (x).begin(), (x).end()
#define mem(x, y) memset((x), (y), sizeof(x))
#define inf 0x3f3f3f3f
#define INF 0x3f3f3f3f3f3f3f3f
using namespace std;
const int N = 2e5 + 10;
int n, m, a[N], b[N], c[N], d[N];
void modify(int x, int k) {
    for (; x <= n; x += x & -x)
        c[x] += k;
}
int ask(int x) {
    int ans = 0;
    for (; x; x -= x & -x)
        ans += c[x];
    return ans;
}
signed main() {
#ifdef LOCAL
    freopen("input.in", "r", stdin);
    freopen("output.out", "w", stdout);
#endif
    IOS;
    cin >> n >> m;
    int res = 0;
    for (int i = 1; i <= n; ++i) {
        cin >> a[i];
        b[i] = i - 1 - ask(a[i]);
        ++d[b[i]];
        res += b[i];
        modify(a[i], 1);
    }
    mem(c, 0);
    modify(1, res);
    int t = 0;
    for (int i = 1; i <= n; ++i) {
        t += d[i - 1];
        modify(i + 1, -(n - t));
    }
    for (int i = 1; i <= m; ++i) {
        int op, x;
        cin >> op >> x;
        x = min(x, n - 1);
        if (op == 1) {
            if (a[x] < a[x + 1]) {
                swap(a[x], a[x + 1]);
                swap(b[x], b[x + 1]);
                ++b[x + 1];
                modify(1, 1);
                modify(b[x + 1] + 1, -1);
            }else {
                swap(a[x], a[x + 1]);
                swap(b[x], b[x + 1]);
                modify(1, -1);
                modify(b[x] + 1, 1);
                --b[x];
            }
        }else
            cout << ask(x + 1) << "\n";
    }
}

以下是前面1 ~ 4结论的证明:

我们从一个样例入手:

5 2 3 1 4

对于其中3,前面有1个元素(5)比这个元素大,所以2 5 3 1 4 -> 2 3 5 1 4 -> 2 3 1 5 4->2 3 1 4 5,  3是"被动交换", 因为3之前比3大的数一定会跟3交换,交换后3一定不能再跟比他大的那个数交换,所以当前一轮3不能实现主动交换. 对于这种数,每一轮冒泡都会讲比他大并且在他前面的一个数放在后面(结论3, 4),这个数对减少逆序对做的贡献为1. 而数组中所有之前的数都比这个数小的数,在经过一轮冒泡后,对减少逆序对的贡献为0. 所以每一轮冒泡逆序对减少的数量为n - x(结论1)

由于每一次领项交换都只会使得逆序对减少1个,并且在冒泡过程中不会新增逆序对,所以冒泡排序总交换的次数为逆序对的总数(结论2).