Probably replace the binary search with liear search would be faster.

The idea is quit simple,

Here is an example

[5,1,4,2,5,2]

Now consider we are trying to find all elements (<2*n - 1) for 5 at index 0.

if we divide it into two parts [5,1,4], [2,5,2], then we sort the right part.

it becomes [2,2,5], since we only need to consider the elements after index 0, also the right array has been sorted, if the found the last element that satisfies the condition, then all the elements before this element would be the result.

And how do we handle the "1" on the left array? since it is also meet the condition. Well it has been handled by the recursive call.

This code is also used DP, since the left hand side array was also sorted, we can save the result for the previous smaller integer, then we only need to consider the elements after the point where the previous iteration stops.

```
class Solution(object):
def reversePairs(self, nums):
return self.helper(nums, 0, len(nums))
def helper(self, nums, l, r):
mid = l + r >> 1
if mid == l: return 0
total = self.helper(nums, l, mid) + self.helper(nums, mid, r)
prev_total = 0
for i in range(l, mid):
target = nums[i] - 1 >> 1
idx = bisect.bisect_right(nums, target, mid, r)
prev_total += idx - mid
mid = idx
total += prev_total
nums[l: r] = sorted(nums[l: r])
return total
```