lintcode-Reverse Pairs

题目

For an array A, if i < j, and A [i] > A [j], called (A [i], A [j]) is a reverse pair.
return total of reverse pairs in A.

举例

Given A = [2, 4, 1, 3, 5] , (2, 1), (4, 1), (4, 3) are reverse pairs. return3

AC代码

class Solution {private:    int* tmp;public:    /**     * @param A an array     * @return total of reverse pairs     */    long long reversePairs(vector<int>& A) {        // Write your code here        int n= A.size();        tmp = new int[n];        return mergeSort(A, 0, n-1);    }    long long mergeSort(vector<int> &A, int l, int r) {        long long ans = 0;        if (l < r) {            int m = (l + r) >> 1;            ans += mergeSort(A, l, m);            ans += mergeSort(A, m+1, r);            ans += merge(A, l, m, r);        }        return ans;    }    long long merge(vector<int> &A, int l, int m, int r) {        int i = l, j = m + 1, k = l;        long long ans = 0;        while (i <= m && j <= r) {            if (A[i] > A[j]) {                tmp[k++] = A[j++];                ans += m - i + 1;            } else {                tmp[k++] = A[i++];            }        }        while (i <= m) tmp[k++] = A[i++];        while (j <= r) tmp[k++] = A[j++];        for (i = l; i <= r; ++i)            A[i] = tmp[i];        return ans;    }};

总结

1.最开始想到的是暴力方式，但是超时。这种方式本质也是一种排序，所有联想到其他效率更高的排序。

2.使用效率高的归并排序
3.归并排序的最好、最坏和平均时间复杂度都是O(nlogn)，而空间复杂度是O(n)，比较次数介于(nlogn)/2和(nlogn)-n+1，赋值操作的次数是(2nlogn)。因此可以看出，归并排序算法比较占用内存，但却是效率高且稳定的排序算法。

思路
1.先递归分组，直到每个元素一个组；

2.从每个组开始归并，归并时，指针分别指向两个组的首位置，比较大小；

3.若左边首位置比右边首位置大，则左边后面所有都比右边这个首位置大，所以此时ans = m - i + 1;

4.当其中一组已经遍历结束了，则将剩下的这一组的元素添加到 tmp里；

5.这样得到的tmp都是有序的；

6.依次返回tmp , ans。最后得到结果。