tryalgo | data structures for preparing programming competitions | Learning library

Let's consider some easy case:

According to your understanding you would create segment tree with 11 - 1 = 10 nodes at base, so something like this:

Notice we have only 9 nodes in base, because first node is for interval [1,2], next one for interval [2,3] and so on

And when you enter some rectangle, you would update it's range based on its y coordinates, so after meeting first one on x=0, your segment tree would look like this:

We would also need to use something called lazy propagation to update active intervals on the tree, so all active intervals would contribute 1 to the sum.

So complexity of your current approach is something like O(K log K) where K = max(y)-min(y)

We can easilly reduce this to O(n log n) where n is number of rectangles.

Notice that only important y coordinates are those that exist, so in this example 1,3,6,11

Also notice that there's at most 2*n such coordinates

So we can map all coordinates to some integers so they fit better in segment tree.

This is known as coordinate compression it can be done with something like this:

1. Store all y coordinates in array
2. sort array and remove duplicates
3. use map or hashMap to map original coordinates to it's position in sorted array

So in our example it would be:

1. [1,3,6,11]
2. no duplicates to remove so array still [1,3,6,11]
3. mp[1]=1, mp[3]=2, mp[6]=3, mp[11]=4

So now algorithm stays the same, yet we can use segment tree with only at most 2*n nodes in it's base.

Also we would need to modify our segment tree a little, instead of keeping which y coordinates are on or off we will now keep which intervals of y coordinates are on/off

So we will have nodes for intervals [y0,y1],[y1,y2], ... for all unique sorted values of y.

Also all nodes will contribute y[i]-y[i-1] to the sum (if they are in range and active) instead of one.

So our new segment tree would be something like this: