c++ 逆序对

class BinaryIndexTree {
public:
    vector<int> bits;

    BinaryIndexTree(int n) {
        bits.resize(n + 1);
    }

    void add(int i, int v) {
        while (i < bits.size()) {
            bits[i] += v;
            i += i & -i;
        }
    }

    int sum(int i) {
        int res = 0;
        while (i > 0) {
            res += bits[i];
            i &= i - 1;
        }
        return res;
    }
};

int mergeSort(vector<int>& data, int low, int high) {
    if (low >= high) {
        return 0;
    }
    int mid = low + (high - low ) / 2;
    int ans = 0;
    ans += mergeSort(data, low, mid);
    ans += mergeSort(data, mid + 1, high);
    vector<int> tmp(high - low + 1);
    int i = low, j = mid + 1, k = 0;
    while (i <= mid || j <= high) {
        int left = i <= mid ? data[i] : INT_MAX;
        int right = j <= high ? data[j] : INT_MAX;
        if (left <= right) {
            tmp[k++] = data[i++];
        } else {
            ans += mid - i + 1;
            tmp[k++] = data[j++];
        }
    }
    for (int i = low; i <= high; i++) {
        data[i] = tmp[i - low];
    }
    return ans;
}


int main() {
    vector<int> data = {1, 3, 2, 3, 1};
    cout << mergeSort(data, 0, data.size() - 1) << endl;

    vector<int> data2 = {1, 3, 2, 3, 1};
#ifdef XXX
    auto x = data2;
    ranges::sort(x);
    x.erase(unique(x.begin(), x.end()), x.end());
    auto get_index = [&](int i) {
        return ranges::lower_bound(x, data2[i]) - x.begin() + 1;
    };
    BinaryIndexTree bit(x.size() + 1);
#else
    BinaryIndexTree bit(ranges::max(data2) + 1);
    int ans = 0;
    for (int i = 0; i < data2.size(); i++) {
        ans += i - bit.sum(data2[i] + 1);
        bit.add(data2[i] + 1, 1);
    }
#endif
    cout << ans << endl;
}