求逆序数（归并排序和树状数组）

题目：

在数组中的两个数字，如果前面一个数字大于后面的数字，则这两个数字组成一个逆序对。输入一个数组,求出这个数组中的逆序对的总数P。并将P对1000000007取模的结果输出。 即输出P%1000000007

归并排序法

在归并过程中，两部分记为左数组和右数组，如果右数组当前的数小于左数组当前的数，那么逆序对总数加左数组剩余元素个数。时间复杂度为O(nlogn)。

代码：

#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
class Solution {  // 归并排序
public:
    int cnt;
    const static int P = 1000000007;
    int InversePairs(vector<int> data) {
        cnt = 0;
        mergesort(data, 0, data.size()-1);
        return cnt;
    }
    void mergesort(vector<int> &data, int l, int r){
        if(l == r) return;
        int mid = (l+r) >> 1;
        mergesort(data, l, mid);
        mergesort(data, mid+1, r);
        vector<int> tmp;
        int ls = l, rs = mid+1;
        while(ls <= mid && rs <= r){
            if(data[ls] <= data[rs])
                tmp.push_back(data[ls++]);
            else{
                cnt = (cnt + mid-ls+1) % P;
                tmp.push_back(data[rs++]);
            }
        }
        while(ls <= mid) tmp.push_back(data[ls++]);
        while(rs <= r) tmp.push_back(data[rs++]);
        int j = 0;
        while(l<=r) data[l++] = tmp[j++];
    }
};

int main(){
    Solution s;
    vector<int> v;
    v.push_back(6),v.push_back(5), v.push_back(3), v.push_back(4), v.push_back(5), v.push_back(6), v.push_back(7), v.push_back(0); // 
    cout<<s.InversePairs(v)<<endl;
}

树状数组法

时间复杂度也是O(nlogn)。

树状数组穿越门：GO

思路：由于数据范围较大，先将数据离散化，即按大小排序，用排序后的位置代替原来的数字（数字间原有大小关系不会改变）。然后按照原来数组顺序，往树状数组中添加数字，再用smaller = sum(idx[i])来获取比当前数字小的数的个数，则i-smaller 就是i之前比i大的数的个数，逆序对总数加上i-smaller。

 

class Solution {  // 树状数组法，因为需要排序，时间复杂度 O(nlogn)
public:
    int lowbit(int k){
        return k & (-k);
    }
    void add(int k, vector<int> &v){
        int size = v.size();
        while(k < size){
            v[k] ++;
            k += lowbit(k);
        }
    }
    int sum(int k, const vector<int> &v){
        int s = 0;
        while(k>0){
            s += v[k];
            k -= lowbit(k);
        }
        return s;
    }
    struct node{
        int x, loc;
        node(int p=0, int q=0): x(p), loc(q){}
        bool operator < (node &p)const{
            return x < p.x;
        }
    };
    int InversePairs(vector<int> data) {
        int size = data.size();
        vector<node> v(data.size());
        vector<int> idx(data.size()+1);
        vector<int> t(data.size()+1);
        const long long P = 1000000007;
        long long ans = 0;
        for(int i = 0; i < data.size(); i++){
            node a(data[i], i+1);
            v[i] = a;
        }
        sort(v.begin(), v.end());
        for(int i = 0; i < v.size(); i++) idx[v[i].loc] = i+1; //原来第i个数现在的下标，因为需要按照原来的顺序添加
        for(int i = 0; i < t.size(); i++) t[i] = 0; //树状数组
        for(int i = 1; i <= v.size(); i++){
            add(idx[i], t);
            int smaller = sum(idx[i], t);
            ans = (ans + i - smaller) % P;
        }
        return ans;
    }
};