You can solve it offline.

1. First sort the queries by increasing order of $$$r$$$.
2. Then maintain an array or map (depends on the values range of $$$a_i$$$) named as $$$previousOccurence$$$, such that $$$previousOccurence[i]=j\textrm{, such that, }j<i\textrm{ and maximum j such that }a_j=a_i$$$. In short, the latest position before $$$i$$$ where $$$a_i$$$ appeared.
3. Traverse through the indices in ascending order while maintaining a Binary Indexed Tree. If you are in position $$$i$$$, update the BIT by adding $$$a_i$$$ at index $$$i$$$, and adding $$$-a_i$$$ at index $$$previousOccurence[a_i]$$$. Now, process all queries which end at $$$i$$$, i.e. the queries where $$$r=i$$$. Then answer of the query will be the sum query on BIT in range $$$[l,r]$$$.
4. You can maintain and update the $$$previousOccurence$$$ array/map while traversing in ascending order.

You can also use segment tree if you want.

I am wondering if we can use Mo's here? transition from f(l, r) to f(l, r + 1) or f(l, r — 1) is log(n) if set is used but the overall time complexity is O(n*sqrt(n)*log(n)) which I think could be too much

(Edited because I misread the question)

Discretize (remember to keep track of the original values because we want to find sum) and use Mo's algorithm. The transitions are $$$O(1)$$$ so the total time complexity is $$$O(Q\log Q+Q\sqrt N)$$$, or amortized $$$O(\sqrt N)$$$.

You could make root n buckets of length root n and keep a frequency map for each.

Then just merge according the map according to your requirements from l to r, so it will be worst case

(root n (left excess) + root n (whole blocks) + root n (right excess) ) * (map size) per query

The problem here is that map size can be the number of distinct elements in our array in worst case, do you have a constraint on a[i]?

If you're given all the queries at the start then you can even do a sweep line and difference array type thing, i think.