First, we'll note a greedy philosophy that if we can simply use a (2 \times 2) square around all trees, that’d be the best solution possible. If not, the only reason why is that some pair of these squares intersects and so we are forced to union them. It turns out there is therefore no decision making that needs to happen here; we simply must find an efficient way of simulating the unions and discovering overlapping pairs.
We can maintain a set of our current answer (the answer for some prefix), and consider the next rectangle one by one. To add rectangle (R) (it'll initially be a (2 \times 2) square, but may grow), first find all rectangles that intersect (R). Expand (R)'s boundaries to include them, and then remove them from our set, and repeat. Once we find no intersections for our expanded (R), add it to the set, and consider the next (2 \times 2) square.
To do this fast, we'll need a data structure to do the following:
- Add one rectangle to the set in (\mathcal{O}(\log^2 N)) time
- Remove one rectangle from the set in (\mathcal{O}(\log^2 N)) time
- Get all rectangles whose outline intersects a query rectangle (R). If there are (s) of these, our time complexity should be at most (\mathcal{O}(s*\log^2 N)). This running time is affordable because any rectangle returned here will immediately be removed, so this cost can be conceptually ignored and amortized into that subsequent removal cost.
To implement this, we'll build a helper structure: a segment tree that holds all vertical lines. It will be able to query all of the (x) coordinates of vertical lines that intersect a given horizontal line.
The structure consists of an outer segment tree over all (x)'s. For a node (n) in the outer segment tree which is responsible for (x)'s in the range ([l..r]), node (n) will store an implicit segment tree that can tell us all of the (y)'s for which there is a vertical line with an (x) coordinate in ([l..r]). To answer a query for all intersecting segments in range ([l..r]), we can walk the outer segment tree, only going down a layer if the implicit segment tree at some node tells us that we’ll find an intersecting segment by going down that path. We can make implementation a bit faster by giving a unique ID to each rectangle’s initial borders. That way we can guarantee there’s at most one rectangle with a vertical line at any particular (x).
This segment tree lets us add vertical lines and query horizontal ones, so we’ll create another copy of it of add horizontal lines and query vertical ones.
Using the above operations, we can repeatedly add a rectangle and union it with any rectangles which intersect at a border. However, there’s still one case this doesn’t catch: it’s possible that one rectangle grows quite large and then contains another smaller rectangle. To handle this, we can do a simple line sweep at the end to catch any rectangles that are completely inside another. Specifically, we can sweep across (x)'s with an event for each rectangle’s left side (start event) and right side (end event) and maintain a segment tree of which (y)'s are inside a rectangle. At a start event, if we’re inside a larger rectangle, then we can mark the inner rectangle as "dead" and not add its area to the answer.
This gives us a final solution that runs in (O(N*\log^2 N)) time and is fast enough to solve all cases even in Java.