Refined Buneman Trees

a b c d
root
ab
cd
Figure 8.2: Updating the quad tree by propagating changes upward.
8.1 Complexity analysis
For every node in our quad tree we wish maintain information about the minimum
matrix entry in the subtree of that node. That way we can, at any time,
find the minimum entry of the matrix in constant time by looking it up in
the root node. We can keep the tree updated by making leaf nodes propagate
changes upward in the tree, at a price proportional to the height of the tree; for a
balanced quad tree spanning an n×n matrix the height is log 4 (n 2 )=2∗log 4 (n),
so the time spent propagating changes upward through the tree is O(log 4 (n)).
Unfortunately, when we are using the quadtree to support construction of
single linkage clustering trees, we need to update two rows and two columns in
the matrix for each iteration, which would then take time O(n log 4 (n)) if we
needed to propagate values upward through the tree every time, and we can
afford to spend no more than linear time. We can also not afford to update
(re-initialise) the whole tree since that would take time O(n 2 ).
Luckily, it is possible to optimize the update procedure under these specific
circumstances. It turns out that it is possible to update the tree in linear
time when changing precisely exactly one row or column. This is due to the
geometric dependency of the nodes, as illustrated in Figure 8.2. It clearly shows
that the upward propagation of changes introduces redundancy, for example
would changes to entries a and b share almost identical paths toward the root.
By cutting down on this redundancy we can shave off a bit of the running time.
We can ask ourselves how many nodes in the quad tree we need to update, in
total. The answer is that after updating a row of n entries in the matrix we
need to update n/2 entries in the first layer of the quad tree, n/4 entriesinthe
second layer, and so on. This gives us
n + n 2 + n 4
+ ... +1≤ 2n
56