动态统计逆序对 （树状数组 twopointer）

动态统计逆序对

逆序对是一个非常经典的问题，对于一个序列Z，如果有 i < j 并且 Zi>Zj， 则我们称 (i,j)为一个逆序对。
但是逆序对虽然经典，却一个非常困难的问题因为列但是逆序对 。所以为简化问题，我们给定一个长度为N的序列Z和一个参数k， 我们希望知道有多少个 (L,R)满足 1≤L < R≤N，且Z1,Z2,⋯,ZL,ZR,⋯,ZN的逆序 对个数不超过k。

【输入格式】
第一行两个整数N,k。
接下来一行N个整数代表序列。

【输出格式】
一 行一个整数代表答案 。

【样例输入1】
3 1
1 3 2
【样例输出1】
3

【样例输入2】
5 2
1 3 2 7
【样例输出2】
6

【数据范围与规定】
对于 100%的数据， 1≤N≤10^5,1≤Zi≤10^9,k≤10^18.

思路：
由于这个求逆序对的方式比较特殊，又考虑这个数据范围，只能是O（n）扫一遍了。所以就考虑动态维护，用两个值域树状数组维护前缀和后缀，动态统计逆序对，就可以用twopointer扫过去了。

#include <cstdio>
#include <algorithm>
#include <iostream>
#define LL long long
using namespace std;

const int N = 100010;

int n, tot;
LL k, cnt, ans;
int cl[N], cr[N], a[N], mp[N];

inline const int read(){
    register int x = 0;
    register char ch = getchar();
    while(ch < '0' || ch > '9') ch = getchar();
    while(ch >= '0' && ch <= '9') x = (x<<3) + (x<<1) + ch - '0', ch = getchar();
    return x;
}

inline void modifyl(int x, int delta){
     for(int i=x; i; i-=(i&-i) ) cl[i] += delta;
}

inline int queryl(int x){
    int res = 0; ++x;
    for(int i=x; i<=n; i+=(i&-i) ) res += cl[i];
    return res;
}

inline void modifyr(int x, int delta){
     for(int i=x; i<=n; i+=(i&-i) ) cr[i] += delta;
}

inline int queryr(int x){
    int res = 0; --x;
    for(int i=x; i; i-=(i&-i) ) res += cr[i];
    return res;
}

inline void two_pointer(){
    int l = 1, r = 2;
    for(int i=n; i>=r; --i) {
        modifyr(a[i], 1);
        cnt += (LL)queryr( a[i] );
    }
    while(r <= n){
        modifyl(a[l], 1);
        cnt += (LL)queryl(a[l]) + (LL)queryr(a[l]);
        while(cnt > k){
            if(r > n) return;
            cnt -= (LL)queryl(a[r]) + (LL)queryr(a[r]);
            modifyr(a[r], -1); r++;
        }
        ans += (LL)(n - r + 1); l++;
        if(l == r) {
            cnt -= (LL)queryl(a[r]) + (LL)queryr(a[r]);
            modifyr(a[r], -1); r++;
        }
    }
}

int main(){
    freopen ("a.in", "r", stdin);
    freopen ("a.out", "w", stdout);
    cin >> n >> k; 
    for(register int i=1; i<=n; ++i) {
        a[i] = read(); 
        mp[++tot] = a[i];
    }
    sort(mp+1, mp+1+tot);
    tot = unique(mp+1, mp+1+tot) - mp - 1;//离散化 
    for(register int i=1; i<=n; ++i)
        a[i] = lower_bound(mp+1, mp+1+tot, a[i]) - mp;
    two_pointer();
    cout << ans << endl;
}