I've been recently thinking about this problem:

Given array of n integers and q queries( l, r pairs ). For each query you need to count number of inversions( i, j pairs such that i < j and a[i] > a[j] ) in subarray from l to r. And you have to answer the queries online(you're not given all queries beforehand).

I was able to come up with a solution that i'd describe below, but I'd like to know if it's possible to solve the problem with better complexity.

So, my solution:

1) preprocessing

Let's divide our array into sqrt(n) blocks, each sized sqrt(n), and merge-sort elements inside each, counting number of inversions in it. Then, for each pair of blocks, count number of inversions such that first element lies within first block and second lies within second block. We can do this using binary search, because each block is sorted already. After that, for each sqrt-block-range( [l, r] range such that l is a left border of one block and r is a right border of other block ) we'd find number of inversions in it by summing precalculated values( inversions in each block and inversions in pairs of blocks). There are around n pairs and ranges so we can do all preprocessing in O(n * sqrt(n) * log(n)). We also need to build merge-sort tree on the array for queries.

2) queries

We already know answer for sqrt-block-range that lies within query range. Then we just need to count inversions that include elements outside sqrt-block-range. There no more than 2 * sqrt of such elements, so we can do this with binary search in merge-sort tree in O(sqrt(n) * log^2(n)), or in O(sqrt(n) * log(n)) with partial cascading.

Overall complexity: O((n + q) * sqrt(n) * log(n)) with partial cascading.

So what are your thoughts, can it be solved faster?

P.S. Sorry for my poor English.

Auto comment: topic has been updated by madn (previous revision, new revision, compare).Edit: I missed something so this was wrong XD.

It is O(N lg N) for each query, because you merge sorting a segment of array, is not it?

yeah I had a mistake in my solution, I didn't mean to do it repeatedly for every query, but I definitely missed something. oops :P

yes, it can be (with something of classic sqrt-decomp and MO's algo)

1) divide array to blocks of size

2) calculate answers for all segments [

L,r] whereL— start of block andr— arbitrary index. Similary for all segments [l,R],R— end of the block. It needs two tables with memory.3) answer on query [

l,r]: findLandRsuchl≤L≤R≤r. preanswer isinvs[L][r] +invs[l][R] -invs[L][R]. remains add inversionsi,jsuchl≤i<L≤R<j≤r(on corners). it can be done with two pointers if you have sorted elements on each block.So, 2) can be done in time (yes i not described it, try to think about dynamic prog) and 3) in per query

Related:

https://discuss.codechef.com/questions/38033/iiti15-editorial

https://www.hackerearth.com/practice/data-structures/advanced-data-structures/fenwick-binary-indexed-trees/practice-problems/algorithm/sherlock-and-inversions/editorial/