BZOJ 3744: Gty的妹子序列

3744: Gty的妹子序列

Time Limit: 20 Sec  Memory Limit: 128 MB
Submit: 1335  Solved: 379
[Submit][Status][Discuss]

Description

我早已习惯你不在身边，

人间四月天 寂寞断了弦。

回望身后蓝天，

跟再见说再见……

某天,蒟蒻Autumn发现了从 Gty的妹子树(bzoj3720) 上掉落下来了许多妹子,他发现

她们排成了一个序列,每个妹子有一个美丽度。

Bakser神犇与他打算研究一下这个妹子序列,于是Bakser神犇问道:"你知道区间

[l,r]中妹子们美丽度的逆序对数吗?"

蒟蒻Autumn只会离线乱搞啊……但是Bakser神犇说道:"强制在线。"

请你帮助一下Autumn吧。

给定一个正整数序列a,对于每次询问,输出al...ar中的逆序对数,强制在线。

Input

第一行包括一个整数n(1<=n<=50000),表示数列a中的元素数。

第二行包括n个整数a1...an(ai>0,保证ai在int内)。

接下来一行包括一个整数m(1<=m<=50000),表示询问的个数。

接下来m行,每行包括2个整数l、r(1<=l<=r<=n),表示询问al...ar中的逆序

对数(若ai>aj且i<j,则为一个逆序对)。

l,r要分别异或上一次询问的答案(lastans),最开始时lastans=0。

保证涉及的所有数在int内。

Output

对每个询问,单独输出一行,表示al...ar中的逆序对数。

Sample Input

4
1 4 2 3
1
2 4

Sample Output

2

HINT

Source

By Autumn

[Submit][Status][Discuss]

╮(╯▽╰)╭  Gty的撩妹技能我等蒟蒻就是不能比。

分块+主席树+树状数组 随便搞一发就好了（其实调了好久）。

#include <bits/stdc++.h>

namespace fastRead
{
    inline int nextChar(void)
    {
        static const int siz = 1 << 20;

        static char buf[siz];
        static char *hd = buf + siz;
        static char *tl = buf + siz;

        if (hd == tl)
            fread(hd = buf, 1, siz, stdin);

        return int(*hd++);
    }

    inline int nextInt(void)
    {
        register int ret = 0;
        register int neg = false;
        register int bit = nextChar();

        for (; bit < 48; bit = nextChar())
            if (bit == '-')neg ^= true;

        for (; bit > 47; bit = nextChar())
            ret = ret * 10 + bit - '0';

        return neg ? -ret : ret;
    }
}

const int mxn = 50005;

int n, m, h, s[mxn], lastAns = 0;

namespace chairManTree
{
    const int siz = 1000005;

    int tot;
    int cnt[siz];
    int lsn[siz];
    int rsn[siz];

    int root[mxn];

    void insert(int &t, int p, int l, int r, int v)
    {
        t = ++tot;

        lsn[t] = lsn[p];
        rsn[t] = rsn[p];
        cnt[t] = cnt[p] + 1;

        if (l != r)
        {
            int mid = (l + r) >> 1;
    
            if (v <= mid)
                insert(lsn[t], lsn[p], l, mid, v);
            else
                insert(rsn[t], rsn[p], mid + 1, r, v);
        }
    }

    int query(int a, int b, int l, int r, int x, int y)
    {
        if (l == x && r == y)
            return cnt[a] - cnt[b];
        
        int mid = (l + r) >> 1;

        if (y <= mid)
            return query(lsn[a], lsn[b], l, mid, x, y);
        else if (x > mid)
            return query(rsn[a], rsn[b], mid + 1, r, x, y);
        else
            return query(lsn[a], lsn[b], l, mid, x, mid) + query(rsn[a], rsn[b], mid + 1, r, mid + 1, y);
    }

    inline void main(void)
    {
        for (int i = 1; i <= n; ++i)
            insert(root[i], root[i - 1], 1, h, s[i]);
    }

    inline int query(int l, int r, int k)
    {
        if (k > 1)
            return query(root[r], root[l - 1], 1, h, 1, k - 1);
        else
            return 0;
    }
}

namespace binaryInsertTree
{
    int tree[mxn];

    inline void add(int p, int v)
    {
        for (; p <= h; p += p&-p)
            tree[p] += v;
    }

    inline int qry(int p)
    {
        int ret = 0;

        for (; p >= 1; p -= p&-p)
            ret += tree[p];

        return ret;
    }

    inline void init(void)
    {
        memset(tree, 0, sizeof(tree));
    }
}

namespace divideSequence
{
    const int mxt = 255;

    int t, st[mxt], tot, rev[mxt][mxn];

    inline int findStart(int k)
    {
        int lt = 1, rt = tot, mid, ans = 0;

        while (lt <= rt)
        {
            mid = (lt + rt) >> 1;

            if (st[mid] >= k)
                rt = mid - 1, ans = mid;
            else
                lt = mid + 1;
        }

        return ans;
    }

    inline void main(void)
    {
        t = int(sqrt(n) + 0.5);

        for (int i = 1, j = 1; i <= n; i += t, ++j)
        {
            st[j] = i;

            binaryInsertTree::init();

            for (int k = i, sum = 0; k <= n; ++k, ++sum)
            {
                rev[j][k] = rev[j][k - 1];
                rev[j][k] += sum - binaryInsertTree::qry(s[k]);

                binaryInsertTree::add(s[k], 1);
            }

            tot = j;
        }
    }
}

namespace preworkHash
{
    int map[mxn], tot;

    inline int find(int k)
    {
        int lt = 1, rt = tot, mid, ans;

        while (lt <= rt)
        {
            mid = (lt + rt) >> 1;

            if (map[mid] <= k)
                lt = mid + 1, ans = mid;
            else
                rt = mid - 1;
        }

        return ans;
    }

    inline void main(void)
    {
        for (int i = 1; i <= n; ++i)
            map[i] = s[i];

        std::sort(map + 1, map + 1 + n);

        for (int i = 1; i <= n; ++i)
            if (!tot || map[i] != map[tot])
                map[++tot] = map[i];

        for (int i = 1; i <= n; ++i)
            s[i] = find(s[i]);

        h = tot;
    }
}

inline int solve(int l, int r)
{
    int id = divideSequence::findStart(l), st, ret;
    
    if (id)
    {
        st = divideSequence::st[id];
        ret = divideSequence::rev[id][r];
    }
    else
        st = r + 1, ret = 0;

    if (st > r)
        st = r + 1;
    
    for (int i = l; i < st; ++i)
        ret += chairManTree::query(st, r, s[i]);
    
    binaryInsertTree::init();

    for (int i = l, sum = 0; i < st; ++i, ++sum)
    {
        ret += sum - binaryInsertTree::qry(s[i]);
        
        binaryInsertTree::add(s[i], 1);
    }

    return ret;
}

signed main(void)
{
    n = fastRead::nextInt();

    for (int i = 1; i <= n; ++i)
        s[i] = fastRead::nextInt();

    preworkHash::main();

    chairManTree::main();

    divideSequence::main();

    m = fastRead::nextInt();

    for (int i = 1; i <= m; ++i)
    {
        int l = fastRead::nextInt();
        int r = fastRead::nextInt();

        l ^= lastAns;
        r ^= lastAns;

        printf("%d
", lastAns = solve(l, r));
    }
}

@Author: YouSiki