LintCode 532：リバースペア（フェンウィックツリーは、ソート古典的なタイトルをマージ）

532. 逆ペア
     中文英語の
     逆対数値（A [i]が、A [J]）ようにA [i]が> A [J]と、I <Jの対です。配列を指定して、配列内のリバースペアの数を返します。

例
例1

入力：A = [2、4、1、3、5]
出力：3
説明：
（2,1）、（4,1）、（4,3）の逆対である
例2

入力：A = [1、2、3、4]
出力：0
説明：
なし逆対

解決策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. 重いへの注意は、とてもユニーク（）関数は非常に便利です使用しています。
4. A [i]のサイズの初め、C []の比[]上からのものにします。
5. ループのための二つの線順次計算結果を交換することができます。

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

コードは以下の通りであります：

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と同様に、しかし同様に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;
};

解決策3：マージソート
この行を追加する必要があります。
結果= MID + -左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;
};