segment tree snippet

class obj
{
public:
    unordered_map<int, int> mp;

    obj()
    {
    }
};

class segmentTree
{
public:
    vector<obj> segment;
    segmentTree(int n)
    {
        // Creating a segment tree of size 4*N + 1.
        segment = vector<obj>(4 * n + 1);
    }

    void buildTree(vector<int> &arr, int l, int r, int index = 0)
    {
        if (l > r)
        {
            return;
        }

        // It means it has only one element
        if (l == r)
        {
            // segment[index].max_sum = arr[l];
            // segment[index].max_prefix_sum = arr[l];
            // segment[index].max_suffix_sum = arr[l];
            // segment[index].sum = arr[l];
            segment[index].mp[arr[l]]++;
            return;
        }

        int mid = (l + r) / 2;
        int lChild = 2 * index + 1;
        int rChild = 2 * index + 2;

        buildTree(arr, l, mid, lChild);
        buildTree(arr, mid + 1, r, rChild);

        // Merging ans from leftChild and rightChild.
        // segment[index].sum = segment[lChild].sum + segment[rChild].sum;
        // segment[index].max_prefix_sum = max(segment[lChild].max_prefix_sum, segment[lChild].sum + segment[rChild].max_prefix_sum);
        // segment[index].max_suffix_sum = max(segment[rChild].max_suffix_sum, segment[rChild].sum + segment[lChild].max_suffix_sum);
        // segment[index].max_sum = max(segment[lChild].max_sum, max(segment[rChild].max_sum, segment[lChild].max_suffix_sum + segment[rChild].max_prefix_sum));
        for (auto [key, val] : segment[lChild].mp)
        {
            segment[index].mp[key] += val;
        }
        for (auto [key, val] : segment[rChild].mp)
        {
            segment[index].mp[key] += val;
        }
    }

    obj query(int l, int r, int ql, int qr, int index)
    {
        // If the l and r lies inside queries range then that complete node is part of ans.
        if (ql <= l && qr >= r)
        {
            return segment[index];
        }

        int mid = (l + r) / 2;

        // If the leftChild has no overlapping with queries range then ans only lies in right part.
        if (mid < ql)
        {
            return query(mid + 1, r, ql, qr, 2 * index + 2);
        }

        // If the rightChild has no overlapping with queries range then ans only lies in left part.
        if (mid + 1 > qr)
        {
            return query(l, mid, ql, qr, 2 * index + 1);
        }

        obj ans1 = query(l, mid, ql, qr, 2 * index + 1);
        obj ans2 = query(mid + 1, r, ql, qr, 2 * index + 2);

        obj ans;

        // Merging answer from left and right child.
        // ans.sum = ans1.sum + ans2.sum;
        // ans.max_sum = max(ans1.max_sum, max(ans2.max_sum, ans1.max_suffix_sum + ans2.max_prefix_sum));
        // ans.max_prefix_sum = max(ans1.max_prefix_sum, ans1.sum + ans2.max_prefix_sum);
        // ans.max_suffix_sum = max(ans2.max_suffix_sum, ans2.sum + ans1.max_suffix_sum);

        for (auto [key, val] : ans1.mp)
        {
            ans.mp[key] += val;
        }
        for (auto [key, val] : ans2.mp)
        {
            ans.mp[key] += val;
        }

        return ans;
    }

    obj query(int l, int r, int ql, int qr)
    {
        obj ans = query(l, r, ql, qr, 0);
        return ans;
    }
};