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. return 3

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。最后得到结果。