如何使用段树计算数组中的反转次数答案

【问题标题】：How to count number of inversions in an array using segment trees如何使用段树计算数组中的反转次数
【发布时间】：2013-09-16 12:02:01
【问题描述】：

我知道这个问题可以使用修改后的归并排序来解决，我也编写了相同的代码。现在我想用 Segment Tree 来解决这个问题。基本上，如果我们从右到左遍历数组，那么我们必须计算“有多少值大于当前值”。 Segment Tree 是怎么实现这个东西的？

我们必须在分段树节点上存储什么类型的信息？

如果可能，请提供代码。

【问题讨论】：

标签： c++ arrays segment-tree

【解决方案1】：

让我通过一个例子一步一步地解释：

arr      :  4 3 7 1
position :  0 1 2 3

首先，将数组按降序排序为 {value, index} 对。

arr      :  7 4 3 1
index    :  2 0 1 3
position :  0 1 2 3

从左到右迭代每个元素arr[i] -

查询每个元素的index（查询范围[0, arr[i].index]以获取左侧更大的数字）并将查询结果放在输出数组对应的index上。

每次查询后，递增覆盖index的相应段树节点。

这样，我们确保从0 到index - 1 仅获得更大的数字，因为到目前为止仅插入了大于arr[i] 的值。

低于 C++ 的实现会更有意义。

class SegmentTree {

    vector<int> segmentNode;

public:
    void init(int n) {
        int N = /* 2 * pow(2, ceil(log((double) n / log(2.0)))) - 1 */ 4 * n;
        segmentNode.resize(N, 0);
    }

    void insert(int node, int left, int right, const int indx) {
        if(indx < left or indx > right) {
            return;
        }
        if(left == right and indx == left) {
            segmentNode[node]++;
            return;
        }
        int leftNode = node << 1;
        int rightNode = leftNode | 1;
        int mid = left + (right - left) / 2;

        insert(leftNode, left, mid, indx);
        insert(rightNode, mid + 1, right, indx);

        segmentNode[node] = segmentNode[leftNode] + segmentNode[rightNode];
    }

    int query(int node, int left, int right, const int L, const int R) {
        if(left > R or right < L) {
            return 0;
        }
        if(left >= L and right <= R) {
            return segmentNode[node];
        }

        int leftNode = node << 1;
        int rightNode = leftNode | 1;
        int mid = left + (right - left) / 2;

        return query(leftNode, left, mid, L, R) + query(rightNode, mid + 1, right, L, R);
    }

};

vector<int> countGreater(vector<int>& nums) {
    vector<int> result;
    if(nums.empty()) {
        return result;
    }
    int n = (int)nums.size();
    vector<pair<int, int> > data(n);
    for(int i = 0; i < n; ++i) {
        data[i] = pair<int, int>(nums[i], i);
    }
    sort(data.begin(), data.end(), greater<pair<int, int> >());
    result.resize(n);
    SegmentTree segmentTree;
    segmentTree.init(n);
    for(int i = 0; i < n; ++i) {
        result[data[i].second] = segmentTree.query(1, 0, n - 1, 0, data[i].second);
        segmentTree.insert(1, 0, n - 1, data[i].second);
    }
    return result;
}

// Input : 4 3 7 1
// output: 0 1 0 3

这很简单，但不像其他典型的线段树问题那样“明显”。用任意输入的笔和纸进行模拟会有所帮助。

还有其他 O(nlogn) 方法与 BST、Fenwick 树和归并排序。

【讨论】：

【解决方案2】：

解决起来很简单。我们用运算和构造一个大小为n 的空段树。现在从左到右遍历排列元素。段树的叶子中的一个将意味着已经访问过这样的元素。当移动到p[i] 的i-th 元素时，我们将请求计算段树中[p[i],n] 的总和：它只会计算左侧大于p[i] 的元素的数量。最后，将一个放在p[i] 的位置。总时间为O(nlogn)。

【讨论】：