# 493. Reverse Pairs(BST, BIT, MergeSort)

Given an array `nums`, we call `(i, j)` an important reverse pair if `i < j` and `nums[i] > 2*nums[j]`.

You need to return the number of important reverse pairs in the given array.

Example1:

```Input: [1,3,2,3,1]
Output: 2
```

Example2:

```Input: [2,4,3,5,1]
Output: 3
```

Note:

1. The length of the given array will not exceed `50,000`.
2. All the numbers in the input array are in the range of 32-bit integer.

Approach #1: Brute Force.

```class Solution {
public:
int reversePairs(vector<int>& nums) {
int len = nums.size();
int count = 0;
for (int i = 0; i < len; ++i) {
for (int j = i + 1; j < len; ++j) {
if (nums[i] > nums[j] * 2LL) count++;
}
}
return count;
}
};
```

Approach #2: Binary Search Tree.

```class Node {
public:
int val, count_ge;
Node *left, *right;
Node(int val) {
this->val = val;
this->count_ge = 1;
this->left = NULL;
this->right = NULL;
}
};

class Solution {
public:
int reversePairs(vector<int>& nums) {
int len = nums.size();
int count = 0;

for (int i = 0; i < len; ++i) {
count += search(head, nums[i] * 2LL + 1);
}

return count;
}

private:
int search(Node* head, long long val) {
return 0;
else if (head->val == val) {
} else if (head->val > val) {
} else {
}
}

Node* insert(Node* head, int val) {
if (head == NULL) return new Node(val);
else if (head->val < val) {
} else {
}
}
};
```

Approach #3: Binary Index Tree.

```class Solution {
public int reversePairs(int[] nums) {
if (nums == null || nums.length <= 1) return 0;
int n = nums.length;
int[] nums_copy = nums.clone();

Arrays.sort(nums_copy);

int[] BITS = new int[n+1];

int count = 0;

for (int i = n-1; i >= 0; --i) {
count += query(BITS, index(nums_copy, 1.0 * nums[i] / 2));
update(BITS, index(nums_copy, nums[i]));
}

return count;
}

private void update(int[] BIT, int index) {
index = index + 1;
while (index < BIT.length) {
BIT[index]++;
index += index & (-index);
}
}

private int query(int[] BIT, int index) {
int sum = 0;
while (index > 0) {
sum += BIT[index];
index -= index & (-index);
}
return sum;
}

private int index(int[] arr, double val) {
int lo = 0, hi = arr.length;
while (lo < hi) {
int mid = lo + (hi - lo) / 2;
if (arr[mid] >= val) hi = mid;
else lo = mid + 1;
}
return lo;
}
}
```

Approach #4: Mergesort.

```class Solution(object):
def __init__(self):
self.cnt = 0

def reversePairs(self, nums):
"""
:type nums: List[int]
:rtype: int
"""
def msort(lst):
L = len(lst)
if L <= 1:
return lst
else:
return merge(msort(lst[:int(L/2)]), msort(lst[int(L/2):]))

def merge(left, right):
l, r = 0, 0
while l < len(left) and r < len(right):
if left[l] <= 2*right[r]:
l += 1
else:
self.cnt += len(left)-l
r += 1
return sorted(left+right)

msort(nums)
return self.cnt
```

493. Reverse Pairs(BST, BIT, MergeSort)

(0)
(0)