LintCode 532: Reverse Pairs (树状数组，Merge Sort经典题)

532. Reverse Pairs
     中文English
     Reverse pair is a pair of numbers (A[i], A[j]) such that A[i] > A[j] and i < j. Given an array, return the number of reverse pairs in the array.

Example
Example1

Input: A = [2, 4, 1, 3, 5]
Output: 3
Explanation:
(2, 1), (4, 1), (4, 3) are reverse pairs
Example2

Input: A = [1, 2, 3, 4]
Output: 0
Explanation:
No reverse pair

解法1：树状数组
参考的网上答案。
注意:

1. 该解法的C[x]里面的x表示的是x的实际值，而不是下标。
2. 离散话代码非常有用，可以将[3,2,100000]简化为[2,1,3]，并且不影响结果。注意最后要+1。

    for (int i = 0; i < A.size(); ++i) {
            A[i] = lower_bound(sortedA.begin(), sortedA.begin() + uniqLen, A[i]) - sortedA.begin() + 1;
    }

3. 注意去重，所以要用到unique()函数，非常有用。
4. A[i]都要从1开始，C[]的size比A[]多1。
5. 计算result的for循环里面的两行顺序可以互换。

            result += sum(uniqLen) - sum(A[i]);
            add(A[i], 1);

举例：
假设数组A经过离散化之后成为[2,1,4,3]，那么
2进来，C[2]++, C[4]++, result += sum(4) - sum(2); // sum(4)=sum(2)=1, result = 0;
1进来，C[1]++,C[2]++,C[4]++, result += sum(4) - sum(1); // sum(4)=2, sum(1)=1, result = 1;
4进来，C[4]++, result += sum(4)-sum(4) = 0; //result = 1;
3进来，C[3]++, C[4]++, result +=sum(4)-sum(3); //sum(4)=4, sum(3)=3, result = 2
注意sum(3)=C[3]+C[2]+C[1]=3

代码如下:

class Solution {
public:
    /**
     * @param A: an array
     * @return: total of reverse pairs
     */
    long long reversePairs(vector<int> &A) {
        vector<int> sortedA = A;
        sort(sortedA.begin(), sortedA.end());
        uniqLen = unique(sortedA.begin(), sortedA.end()) - sortedA.begin();
        C.resize(uniqLen + 1, 0);
        long long result = 0;

        //discrete A[]
        for (int i = 0; i < A.size(); ++i) {
            A[i] = lower_bound(sortedA.begin(), sortedA.begin() + uniqLen, A[i]) - sortedA.begin() + 1;
        }
        
        for (int i = 0; i < A.size(); ++i) {
            result += sum(uniqLen) - sum(A[i]);
            add(A[i], 1);
        }
        
        return result;
    }


private:
    int uniqLen;
    vector<int> C;
    
    int lowbit(int x) {
        return x & (-x);
    }
    
    int sum(int x) {
        int result = 0;
        for (int i = x; i > 0; i -= lowbit(i)) {
            result += C[i];
        }
        return result;
    }
    
    void add(int x, int v) {
        for (int i = x; i <= uniqLen; i += lowbit(i)) {
            C[i] += v;
        }
    }
};

解法2：类似解法1，但是用brutal force构建类似C[]。时间复杂度O(n^2)。
会超时。

class Solution {
public:
    /**
     * @param A: an array
     * @return: total of reverse pairs
     */
    long long reversePairs(vector<int> &A) {
        vector<int> sortedA = A;
        sort(sortedA.begin(), sortedA.end());
        uniqLen = unique(sortedA.begin(), sortedA.end()) - sortedA.begin();
        C.resize(uniqLen + 1, 0);
        long long result = 0;

        //discrete A[]
        for (int i = 0; i < A.size(); ++i) {
            A[i] = lower_bound(sortedA.begin(), sortedA.begin() + uniqLen, A[i]) - sortedA.begin() + 1;
        }
        
        for (int i = 0; i < A.size(); ++i) {
            for (int j = A[i]; j <= uniqLen; ++j) {
                C[j]++;
            }
            result += C[uniqLen] - C[A[i]];
        }
        
        return result;
    }

private:
    int uniqLen;
    vector<int> C;
};

为什么解法1和解法2可行呢？我们看一下下面的例子：
intput = 2, 4, 1, 3, 5
以解法2为例：
i = 0, 2 is coming, C[] = {0, 1, 1, 1, 1}
i = 1, 4 is coming, C[] = {0, 1, 1, 2, 2}
i = 2, 1 is coming, C[] = {1, 2, 2, 3, 3} result += 2 //3-1=2
说明1前面已经有2个比1大的已经往C[uniqLen]上面加了
i = 3, 3 is coming, C[] = {0, 1, 3, 4, 4} result += 1 //4-3=1
说明3前面已经有1个比3大的已经往C[uniqLen]上面加了
i = 4, 5 is coming, C[] = {0, 1, 3, 4, 5}

解法3：Merge Sort
只需加入这一行即可：
result += mid - left + 1;

class Solution {
public:
    /**
     * @param A: an array
     * @return: total of reverse pairs
     */
    long long reversePairs(vector<int> &A) {
        buf.resize(A.size(), 0);
        return mergeSort(A, buf, 0, A.size() - 1);
    }
private:
    long long mergeSort(vector<int> & A, vector<int> & buf, int start, int end) {
        
        if (start >= end) return 0;
        
        int result = 0;
        int mid = start + (end - start) / 2;
        
        result += mergeSort(A, buf, start, mid);
        result += mergeSort(A, buf, mid + 1, end);
        result += merge(A, buf, start, end);
        
        return result;
    }
    
    long long merge(vector<int> & A, vector<int> & buf, int start, int end) {
        int result = 0;
        int mid = start + (end - start) / 2;
        int left = start, right = mid + 1, index = start;
        
        while(left <= mid && right <= end) {
            if (A[left] <= A[right]) {
                buf[index++] = A[left++];
            } else {
                buf[index++] = A[right++];
                result += mid - left + 1;
            }
        }
        
        while(left <= mid) {
            buf[index++] = A[left++];
        }
        
        while(right <= end) {
            buf[index++] = A[right++];
        }
        
        for (index = start; index <= end; index++) {
            A[index] = buf[index];
        }
        
        return result;
    }
    
    vector<int> buf;
};