Small-To-Large Merging

Merging Data Structures

Obviously linked lists can be merged in $O(1)$ time. But what about sets or vectors?

Let's consider a tree rooted at node $1$, where each node has a color.

For each node, let's store a set containing only that node, and we want to merge the sets in the nodes subtree together such that each node has a set consisting of all colors in the nodes subtree. Doing this allows us to solve a variety of problems, such as query the number of distinct colors in each subtree.

Naive Solution

Suppose that we want merge two sets $a$ and $b$ of sizes $n$ and $m$, respectively. One possiblility is the following:

1for (int x: b) a.insert(x);

which runs in $O(m\log (n+m))$ time, yielding a runtime of $O(N^2\log N)$ in the worst case. If we instead maintain $a$ and $b$ as sorted vectors, we can merge them in $O(n+m)$ time, but $O(N^2)$ is also too slow.

Better Solution

With just one additional line of code, we can significantly speed this up.

1if (a.size() < b.size()) swap(a,b);
2for (int x: b) a.insert(x);

Note that swap exchanges two sets in $O(1)$ time. Thus, merging a smaller set of size $m$ into the larger one of size $n$ takes $O(m\log n)$ time.

Claim: The solution runs in $O(N\log^2N)$ time.

Proof: When merging two sets, you move from the smaller set to the larger set. If the size of the smaller set is $X$, then the size of the resulting set is at least $2X$. Thus, an element that has been moved $Y$ times will be in a set of size at least $2^Y$, and since the maximum size of a set is $N$ (the root), each element will be moved at most $O(\log N$) times.

Generalizing

A set doesn't have to be an std::set. Many data structures can be merged, such as std::map or std:unordered_map. However, std::swap doesn't necessarily work in $O(1)$ time; for example, swapping two arrays takes time linear in the sum of the sizes of the arrays, and the same goes for indexed sets. For two indexed sets a and b we can use a.swap(b) in place of swap(a,b).

Problems