HDU5196--DZY Loves Inversions 树状数组 逆序数

题意查询给定[L, R]区间内 逆序对数 ==k的子区间的个数。

我们只需要求出 子区间小于等于k的个数和小于等于k-1的个数，然后相减就得出答案了。

对于i(1≤i≤n)，我们计算ri表示[i,ri]的逆序对数小于等于K，且ri的值最大。（ri对应代码中的cnt数组）

显然ri单调不降，我们可以通过用两个指针扫一遍，利用树状数组计算出r数组。

对于每个询问L,R，我们要计算的是∑i=LR[min(R,ri)−i+1]

由于ri具有单调性，那我们直接在上面二分即可，然后记一个前缀和（s数组）。

#include <set>
#include <map>
#include <cmath>
#include <ctime>
#include <queue>
#include <stack>
#include <cstdio>
#include <string>
#include <vector>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
typedef unsigned long long ull;
typedef long long ll;
const int inf = 0x3f3f3f3f;
const double eps = 1e-8;
const int maxn = 1e5+100;
int n, q, tot, a[maxn];
ll k, vec[maxn];
int lowbit (int x)
{
    return x &  -x;
}
ll arr[maxn];
int M ;
void modify(int x, int d)
{
    while (x < M)
    {
        arr[x] += d;
        x += lowbit(x);
    }
}
ll sum(int x)
{
    ll res = 0;
    while (x)
    {
        res += arr[x];
        x -= lowbit(x);
    }
    return res;
}
ll cnt[2][maxn];
ll s[2][maxn];
ll solve (int L, int R, ll x, int w)                 // 小于等于x的数量
{
    if (x < 0)
        return 0;
    //int tmp = 0;
    int tmp = lower_bound(cnt[w]+L, cnt[w]+R+1, (ll)R) - cnt[w];
    while (tmp >= R+1)                           //  cnt数组中所有数都小于 R时，，得到的tmp是大于R+1的
        tmp--;
    while (cnt[w][tmp] > R && tmp >= L)
       tmp--;
    if (tmp < L)
        return (ll)R*(ll)(R-L+1) - (ll)(L+R)*(ll)(R-L+1)/2;
    return s[w][tmp] - s[w][L-1] - (ll)(R-tmp)*(ll)(R+tmp+1)/2+ (ll)(R-tmp)*(ll)R;
}
int main()
{
    #ifndef ONLINE_JUDGE
        freopen("in.txt","r",stdin);
        freopen("out.txt", "w", stdout);
    #endif
    while (~scanf ("%d%d%I64d", &n, &q, &k))
    {
        M = n + 10;
        memset(arr, 0, sizeof (arr));
        memset(cnt, 0, sizeof (cnt));
        memset(s, 0, sizeof(s));
        for (int i = 0; i < n; i++)
        {
            scanf ("%I64d", vec+i);
            a[i] = vec[i];
        }
        sort (vec, vec+n);
        tot = unique(vec, vec+n) - vec;
        for (int i = 0; i < n; i++)
        {
            a[i] = lower_bound(vec, vec+tot, a[i]) - vec + 2;           //离散化
        }
        ll res = 0;
        //小于等于k
        for (int i = 0, j = 0; i < n; i++)
        {
            for ( ; j < n && res <= k; j++)
            {
                res += (j - i) - sum(a[j]);
                modify(a[j], 1);
            }
            if (res >= k)
                cnt[1][i] = (res > k ? max(0,j -1-1): j-1) ;           // -1是因为 j先加了一下， 才跳出 循环的
            else
                cnt[1][i] = j-1-1;
            s[1][i] = s[1][i-1] + cnt[1][i] - (i);
            modify(a[i], -1);
            res -= sum(a[i]-1);
        }

        //小于等于k-1
        res = 0;
        for (int i = 0, j = 0; i < n; i++)
        {
            for ( ; j < n && res <= (k-1); j++)
            {
                res += (j-i) - sum(a[j]);
                modify(a[j], 1);
            }
            if (res >= k-1)
                cnt[0][i] = (res > (k-1) ? max(j-1-1,0) : j-1);
            else
                cnt[0][i] = j-1-1;

            s[0][i] = s[0][i-1] + cnt[0][i] - (i);
            modify(a[i], -1);
            res -= sum(a[i]-1);
        }
        for (int i = 0; i < q; i++)
        {
            int u, v;
            scanf ("%d%d", &u, &v);
            u--, v--;
            if (u > v)
                swap(u, v);
            ll ans1 = solve(u, v, k, 1);
            ll ans2 = solve(u, v, k-1, 0);
            if (k == 0)
                ans1 += (v-u+1);                            // 考虑形如[a, a]的区间
            printf("%I64d
", ans1-ans2 );
        }
    }
    return 0;
}