LeetCode1649. 通过指令创建有序数组 C++ 树状数组和线段树

树状数组

template <class T> class FenwickTree {
    int limit;
    vector<T> arr;
    //树状数组是从1开始储存的，而不是0
    inline int lowbit(int x) { return x & (-x); }

public:
    FenwickTree(int limit=1) {
        this->limit = limit;
        arr = vector<T>(limit + 1);
    }
    void resize(int limit){
        this->limit = limit;
        arr.resize(limit+1);
    }
    inline void update(int idx, T delta) {
        for (; idx <= limit; idx += lowbit(idx))
            arr[idx] += delta;
    }

    inline T query(int idx) {
        T ans = 0;
        for (; idx > 0; idx -= lowbit(idx))
            ans += arr[idx];
        return ans;
    }
};
class Solution {
public:
    FenwickTree<int> tree;
    int createSortedArray(vector<int>& instructions) {
        tree.resize(1e5);
        long long ans=0;
        for(auto x:instructions){
            ans+=min(tree.query(x-1),tree.query(1e5)-tree.query(x));
            tree.update(x,1);
        }
        return ans%(long long)(1e9+7);
    }
};

线段树

class Solution {
public:
    static const int N = 1e5 ;
    struct TreeNode {
        int l, r,sum;
    } tr[4*N];
    void pushup(TreeNode &f, TreeNode &l, TreeNode &r)
    {
        f.sum=l.sum+r.sum;
    }

    void build(int u, int l, int r)
    {
        if (l == r)
        {
            tr[u] = { l, l, 0 };
            return ;
        }
        tr[u].l = l; tr[u].r = r;
        int mid = l + r >> 1;
        build(u * 2, l, mid);
        build(u * 2 + 1, mid + 1, r);
        pushup(tr[u], tr[u * 2], tr[u * 2 + 1]);
    }

    int query(int u,int l, int r)   // >val
    {
        if(l>r) return 0;
        if (tr[u].l >= l && tr[u].r <= r) {
            return tr[u].sum;
        }
        int mid = tr[u].l + tr[u].r >> 1;
        if (r <= mid) return query(u * 2, l, r);
        else if (l > mid) return query(u * 2 + 1,l, r);
        else
        {
            return  query(u * 2, l, r)+query(u * 2 + 1,l, r);
        }
    }
    void modify(int u, int x)   
    {
        if (tr[u].l == x && tr[u].r == x)
        {
            tr[u].sum++;
            return ;
        }
        int mid = tr[u].l + tr[u].r >> 1;
        if (x <= mid) modify(u * 2, x);
        else  modify(u * 2 + 1, x);
        pushup(tr[u], tr[u * 2], tr[u * 2 + 1]);
    }

    int createSortedArray(vector<int>& instructions) {
        long long ans=0;
        int n=instructions.size();
        build(1,1,1e5);
        for(int i=0;i<n;i++) {
            int x=instructions[i];
            ans+=min(query(1,x+1,1e5), query(1,1,x-1));
            modify(1,x);
        }
        return ans%(long long )(1e9+7);
    }
};