Segment tree count of time units invigilator required

#include <bits/stdc++.h>
#include <cstdio>
using namespace std;

#include "/home/ad/ad_debugger.h"
Debugger D;
#define d(x)            \
    cerr << #x << "  "; \
    D.print(x);         \
    cerr << '\n';

#define da(x, n)       \
    cerr << #x << " "; \
    D.print(x, n);     \
    cerr << "\n";

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;
    }
};

vector<int> minTime(vector<int> start, vector<int> end, vector<int> q_start, vector<int> q_end, int k)
{
    int n = start.size();

    int maxi = *max_element(end.begin(), end.end());
    vector<int> prefix(maxi + 2, 0); // in case we need index maxi+1

    for (int i = 0; i < n; i++)
    {
        int s = start[i];
        int e = end[i];
        prefix[s] += 1;
        prefix[e + 1] -= 1;
    }

    for (int i = 1; i < prefix.size(); i++)
    {
        prefix[i] += prefix[i - 1];
    }

    segmentTree ST(n);

    ST.buildTree(prefix, 0, prefix.size() - 1);

    vector<int> ans(q_start.size());

    for (int i = 0; i < q_start.size(); i++)
    {
        int s = q_start[i];
        int e = q_end[i];

        obj temp = ST.query(0, prefix.size() - 1, s, e);
        int cnt = 0;
        for (auto [key, val] : temp.mp)
        {
            if (key >= k)
            {
                cnt += val;
            }
        }
        ans[i] = cnt;
    }
    return ans;
}

int main()
{
    // vector<int> start = {1, 3, 2, 5};
    vector<int> start = {1,2,4};
    // vector<int> end = {3, 5, 3, 6};
    // vector<int> end = {3,4,5};
    vector<int> end = {4,5,5};
    // vector<int> q_start = {1, 3};
    vector<int> q_start = {2,5};
    // vector<int> q_end = {4, 6};
    vector<int> q_end = {6,6};
    int k = 3;

    vector<int> ans = minTime(start, end, q_start, q_end, k);
    // d(ans);

}