Spanning Trees in Multipartite Geometric Graphs

# Spanning Trees in Multipartite Geometric Graphs

Ahmad Biniaz School of Computer Science, Carleton University. Supported by NSERC.
Prosenjit Bose1    David Eppstein Computer Science Department, University of California, Irvine. Supported by NSF grant CCF-1228639.
eppstein@ics.uci.edu
Anil Maheshwari1    Pat Morin1    Michiel Smid1
1footnotemark: 1
October 11, 2019
###### Abstract

Let and be two disjoint sets of points in the plane where the points of are colored red and the points of are colored blue, and let . A bichromatic spanning tree is a spanning tree in the complete bipartite geometric graph with bipartition . The minimum (respectively maximum) bichromatic spanning tree problem is the problem of computing a bichromatic spanning tree of minimum (respectively maximum) total edge length.

1. We present a simple algorithm that solves the minimum bichromatic spanning tree problem in time. This algorithm can easily be extended to solve the maximum bichromatic spanning tree problem within the same time bound. It also can easily be generalized to multicolored point sets.

2. We present -time algorithms that solve the minimum and the maximum bichromatic spanning tree problems.

3. We extend the bichromatic spanning tree algorithms and solve the multicolored version of these problems in time, where is the number of different colors (or the size of the multipartition in a complete multipartite geometric graph).

## 1 Introduction

Let and be two disjoint sets of points in the plane, and suppose that the points of are colored red and the points of are colored blue. A bichromatic spanning tree on is a spanning tree in the complete bipartite geometric graph with bipartition . In other words, a bichromatic spanning tree is a spanning tree in which every edge has a red endpoint and a blue endpoint. The minimum bichromatic spanning tree (MinBST) problem is the problem of computing a spanning tree in whose total edge length is minimum. Similarly, the maximum bichromatic spanning tree (MaxBST) problem is the problem of computing a spanning tree in whose total edge length is maximum. A natural extension of the MinBST and MaxBST problems is to have more than two colors. In this multicolored version, the input points are colored by colors, and we are looking for a minimum/maximum spanning tree in which the two endpoints of every edge have distinct colors. In other words, we look for a minimum/maximum spanning tree in a complete -partite geometric graph. We call these problems Min--ST and Max--ST, respectively. See Figure 1.

The MinBST and MaxBST problems are natural extensions of the well-known Euclidean minimum and maximum spanning tree problems, which we refer to as the MinST and MaxST problem, respectively, and are defined as follows. Given a set of points in the plane, in the MinST (resp. MaxST) problem we seek a spanning tree of minimum (resp. maximum) edge length in the complete geometric graph . It is well known that any MinST of is a subgraph of the Delaunay triangulation of . Thus, one can compute, in time, a MinST by first computing the Delaunay triangulation and then running Kruskal’s or Prim’s algorithm on it. Monma and Paterson  showed that a MaxST of can also be computed in time. They also proved a matching lower bound for computing a MaxST in the algebraic computation-tree model.

For the MinBST and the MaxBST problems, let . Then has edges. By running Prim’s minimum spanning tree algorithm on one can solve the MinBST problem in time. By combining Prim’s algorithm with the currently best known dynamic data structure for the bichromatic closest pair problem (see Kaplan ) this problem can be solved in time. The MaxBST problem can be solved in time by running Prim’s algorithm on with negated edge lengths. Because of their geometric nature, we expect faster algorithms for these problems. In this paper, we will study the MinBST, MaxBST, Min--ST, and Max--ST problems.

### 1.1 Our contribution

The algorithms presented in this paper are base on Borůvka’s minimum spanning tree algorithm. In Section 2 we present a simple algorithm that solves the MinBST problem in time. We extend this algorithm to solve the MaxBST problem within the same time bound. Also, we extend this algorithm to solve the Min--ST and Max--ST problems in time. By making more use of geometry, in Section 3 we present an algorithm that solves the MinBST problem in time. In Section 4 we show how to adopt the MinBST algorithm and solve the MaxBST problem also in time. In Section 5 we use the MinBST and MaxBST algorithms and solve the Min--ST and Max--ST problems in time.

## 2 Borůvka’s algorithm and binary numbering

In this section we present a simple algorithm that solves the MinBST and MaxBST problems in time, where is the total number of input points. Moreover, we show that this algorithm can be extended to solve the Min--ST and Max--ST problems in time, where is the number of colors. First, we present the algorithm for the MinBST problem, and then we will describe how to extend this algorithm to solve the other problems. Our algorithm is based on Borůvka’s minimum spanning tree algorithm. Recall that we are given two sets and of red and blue points in the plane, respectively, and we want to compute a minimum bichromatic spanning tree (MinBST) in . Let .

Borůvka’s algorithm maintains a forest (initially with each vertex in its own one-node tree) and at each stage of the algorithm adds a set of edges, where each edge is the shortest edge connecting a tree to a vertex outside of it. The number of trees goes down by a factor of two or more in each stage, so there are stages. To use this algorithm for bichromatic point sets, we need to find for every tree in the current stage, the shortest bichromatic edge that connects a point of to an oppositely-colored point outside of . We briefly describe how to find, for one stage of Borůvka’s algorithm, all these shortest bichromatic edges in time. This implies that Borůvka’s algorithm solve the MinBST problem in time.

To find all shortest bichromatic edges, in the current stage, it is sufficient to solve the following problem: given a partition of the points into subsets (the vertices of the current trees), find for each point the nearest oppositely-colored point that is not in ’s subset. We call this the all nearest unrelated points problem. We show how to solve the all nearest unrelated points problem in time. Number the subsets of the partition arbitrarily, as integers from to one less than the number of subsets, and represent each of these numbers in binary as a sequence of bits. Define a canonical set to be the subset of points that belong to a set whose label’s th bit is (for ) and whose color is (for ). Then for a point , the set of points that are unrelated to can be expressed as the union of logarithmically many canonical sets , one for each possible value of , where is the complement of the th bit of the label for ’s subset, and is the opposite color to . Therefore, we can solve the all nearest unrelated points problem by computing a Voronoi diagram for each canonical set, and building a point location data structure for each Voronoi diagram. Then, for each point we query the canonical sets whose union is the set of unrelated points to , and combine the results of the queries to find ’s nearest unrelated point. There are Voronoi diagrams, each of which can be built in time , after which we spend time per point to query these diagrams. So the total time for computing all nearest unrelated points is . (It is possible to build the Voronoi diagrams more quickly by computing a single Voronoi diagram of all of the points and using it to guide the construction of the Voronoi diagrams of the subsets—see [4, 9]—but this would not speed up the overall algorithm because of the point location time.)

Since Borůvka’s algorithm takes logarithmically many stages, and each stage can be performed using a single computation of all nearest unrelated points, the total time to construct a bichromatic minimum spanning tree is .

### 2.1 Extension to the MaxBST problem

The combination of Borůvka’s algorithm and the binary numbering method of the previous section can also be used to solve the MaxBST problem. For this problem, at each stage of Borůvka’s algorithm we add the longest edges connecting each tree to a vertex outside of it. Therefore, we compute the farthest-point Voronoi diagram for each canonical set, and locate each point in these diagrams. Since the farthest-point Voronoi diagram of points can be constructed in time, the above algorithm solves the MaxBST problem in time.

### 2.2 Extension to the Min-k-ST and Max-k-ST problems

In this section we extend the algorithm of the previous section to solve the Min--ST and Max--ST problems. We describe the algorithm for the Min--ST problem; the algorithm for the Max--ST problem is analogous.

Recall that in the Min--ST problem, the input points are colored by colors, and we want to compute a minimum spanning tree in which the two endpoints of every edge have distinct colors. To use Borůvka’s algorithm for this problem, we need to find for each point a nearest unrelated point, i.e., a nearest point of different color that is not in its own tree/component. Number the trees, and represent each of these numbers in binary as a sequence of bits. Number the colors by , and represent each of these numbers in binary as a sequence of bits. Define a canonical set to be the subset of points that (i) their color’s th bit is , and (ii) belong to a tree whose label’s th bit is ; notice that . Then, for a point , the set of points that are unrelated to can be expressed as the union of canonical sets , one for each possible pair , where is the complement of the th bit of the label for ’s tree, and is the complement of the th bit of ’s color. To find a nearest unrelated point to , we locate in the Voronoi diagrams of the canonical sets whose union is the set of unrelated points to . There are canonical sets. It takes time to build the Voronoi diagrams for all these sets, and also to locate all the points in these diagrams. Thus, the total time to solve the Min--ST problem (and also the Max--ST problem) is .

## 3 The minimum bichromatic spanning tree problem

Recall that we are given two sets and of red and blue points in the plane, respectively, and we want to compute a minimum spanning tree in in . In this section, we present an algorithm that computes a MinBST in in time, where . In fact, we show how to find, for all stages of Borůvka’s algorithm, all shortest bichromatic edges in time. Our algorithm is optimal because finding the bichromatic closest pair has an lower bound (see ). Our algorithm is summarized below.

###### Observation 1.

In any minimum bichromatic spanning tree, every point is connected to a closest point of opposite color.

The correctness of algorithm MinBST follows from Observation 1 and from the correctness of Borůvka’s algorithm. Before analyzing the running time of this algorithm we introduce some notation. For a point set in the plane, let denote the Delaunay triangulation of , and denote the Voronoi diagram of . Let denote the Voronoi region/cell of a point in . For two disjoint point sets and , where each of the points in is colored either red or blue, we define the bichromatic closest pair as a closest red-blue pair between and .

Step 1 in algorithm MinBST takes time; a straightforward solution is to locate all points of in and all points of in . In the rest of this section we show how to run Borůvka’s algorithm (step 2) in time. Notice that, in algorithm MinBST, one can combine steps 1 and 2 and just run Borůvka’s algorithm on the input point set. However, having step 1 separately, will simplify the running time analysis.

Recall that Borůvka’s algorithm maintains a forest (a set of trees which we call components) and at each stage adds the shortest edges connecting each component to a vertex outside of it. Thus, in each stage the number of components goes down by a factor of two or more. The output of the last stage is a single component which is a minimum spanning tree. Therefore, there are stages in total. Consider one stage of Borůvka’s algorithm. Let be the input components to that stage. Let , and for each , let denote the set of points in . Note that, after step 1, we have . Moreover, each point is in the same component as its closest point of opposite color. We have to find for each component , the shortest edge connecting a point in to an oppositely-colored point outside of . In fact, we have to solve the following problem which we call “all bichromatic closest pairs”:

###### Problem.

Given a set of red and blue points in the plane and a partition of into such that each point of is in the same set as its closest point of opposite color. Find for each , the closest red-blue pair between and , i.e., .

Let and denote the set of red and blue points of , respectively. Then, can be computed by taking the shorter of and . The following algorithm finds for all . By swapping the role of red and blue points, one can compute for all .

We prove the correctness of algorithm All-Blue-BCP by a non-trivial extension of the proof of Theorem 3.1 in  to our bichromatic setting. The set , that is computed in line 3 in algorithm All-Blue-BCP, contains the points of that are adjacent to some point of in ; see Figure 2(a). To simplify the notation, we write for . In line 5, the algorithm computes as the endpoints of a shortest red-blue edge in . Thus, we have to prove that . Take any . Let where and . To prove the correctness of this algorithm, we just need to show that is in . In order to show this, we prove that for some point , is an edge of ; this guarantees that algorithm All-Blue-BCP adds to in line 3. Figure 2: Proof of the correctness of algorithm All-Blue-BCP: (a) The input components to one stage of Borůvka’s algorithm. Solid blue points belong to Bi and solid red points belong to Ti. (b) p is a point in ¯¯¯¯¯¯Ri that is closest to b, and r is a point in R that is closest to b.

Consider the Voronoi diagram . Because is a point of that is closest to , lies in the Voronoi cell . Since is convex, the line segment is inside this cell; see Figure 2(b). Thus, no edge of crosses . Recall that ’s closest red point in , say , is in the same component as . Thus, and also . Now, imagine the construction of by inserting the points of to . Since is the closest red point to , lies in . Because of this, and since and are two different cells in , there are some edges of that cross ; see Figure 2(b). Among those edges, consider the edge whose intersection with is closest to . Let be the point such that is a common edge between and ; notice that . By inserting the points of to , the Voronoi cells of do not get larger. This implies that the point —which has on its boundary in —belongs to . Therefore, in , there is an edge between and ; that edge corresponds to in . Notice however that is not necessarily itself. Moreover, if is on the boundary of , then passes through , and . This finishes the proof for the correctness of algorithm All-Blue-BCP.

###### Lemma 1.

For any , with , and any partition of , the total size of the sets , that are computed in line 3 of algorithm All-Blue-BCP, is . Moreover, having , the sets can be computed in time.

###### Proof.

For each and each we define

 f(p,i)={1if p∈Ti0if p∉Ti.

The number of sets that a red point belongs to is at most ’s degree in . Thus,

 k∑i=1|Ti|=k∑i=1∑p∈Rf(p,i)=∑p∈Rk∑i=1f(p,i)⩽∑p∈Rdeg(p)⩽2(3|R|−6),

where the last inequality is valid because is a planar graph and has at most edges. Therefore, the total size of the sets is . Moreover, these sets can be computed in time as follows. Take any edge of . If and belong to a same set , then do nothing. If and belong to two different sets of the partition, say and , then add to and add to . ∎

Now we analyze the running time of algorithm All-Blue-BCP. It takes time to compute . Since the total size of the sets is , and, by Lemma 1, the total size of the sets is , we can compute for all in time; recall that . Thus the total running time of algorithm All-Blue-BCP is , and hence, the running time of algorithm MinBST is . In the rest of this section, we show how to improve the running time of MinBST to .

Kirkpatrick  shows how to merge two Delaunay triangulations in linear time; that is, given and , how to find in time . Löffler and Mulzer  show that the reverse operation can also be done in linear time. That is, one can split to obtain and in time . We use these two results, and show how to run algorithm All-Blue-BCP during all stages of Borůvka’s algorithm in total time. In order to show this, we use the following fact: if we have , and for all , then one execution of algorithm All-Blue-BCP (during one stage of Borůvka’s algorithm) takes time; this is because the total size of the sets is , and by Lemma 1 the sets can be computed in time and their total size is , and thus, by the result of  we can compute for all and also all bichromatic closest pairs in time.

We compute at the beginning of algorithm MinBST. As discussed earlier we can compute and for all input components of the first stage of Borůvka’s algorithm in time. Based on the discussion above, we are going to show how to retrieve all and for input components of the next stage of Borůvka’s algorithm from all and of input components of the current stage of Borůvka’s algorithm. Although for simplicity we use index to refer to the components of both the current and the next stages, notice that the number of components and their sizes vary from one stage to another.

Consider one stage of Borůvka’s algorithm, and let be the number of input components to this stage, where . Without loss of generality let , with , denote a subset of the input components that should be connected together and be passed to the next stage as a single component. Let denote the resulting component. Let and denote the sets of red and blue points of , respectively. Let be the point set that will be computed (with respect to ) in line 3 of All-Blue-BCP in the next stage. Notice that is the union of the sets , and is the union of the sets . Recall that contains the points of that have a Delaunay neighbor in . Thus, is the union of the sets minus the set .

In order to compute for the next stage, we iteratively merge the Delaunay triangulations of the two smallest sets among . A monotone priority queue (see ) can be used to find the two smallest sets iteratively; the total time for the queue operations is proportional to the sum of the number of sets and the size of the largest set. We compute during the same merge process that we compute , i.e., whenever we merge and , we also merge and . Let and . Let be the set that will be computed in line 3 of All-Blue-BCP with respect to . By the result of  we can compute in time by merging and . We describe in more detail how to compute and also . Let . We compute as follows: take any point , if, in , is adjacent to a point in , then add both and to . Then, . By the result of  we can compute in time by merging and . Then, by the result of  we can compute (and also ) in time by splitting .

We analyze the total running time of step 2 of algorithm MinBST as follows. Let be the sets of blue points of components obtained in step 1 of algorithm MinBST. Imagine a binary tree that is obtained as follows. has leaves that are labeled . Recall that in algorithm All-Blue-BCP, we merge the Delaunay triangulations in a binary manner. Each time we merge two Delaunay triangulations and , we create a node with label in and connect the nodes and as its children. The label of the root of is .

###### Lemma 2.

The height of is .

###### Proof.

Take any leaf of . Let be the path from to

. Partition the edges of into , where is the set of edges connecting a node in one stage of Borůvka’s algorithm to a node in the next stage, and is the set of edges connecting two nodes within one stage of Borůvka’s algorithm. See the figure to the right; the fat edges belong to , while the other edges belong to . Since the number of stages in Borůvka’s algorithm is , the number of edges in is . Imagine walking up , starting from and ending at . Each time we go up and pass two consecutive edges of , the size of the label of that node gets doubled. To see why this is true, consider two consecutive merges of a node with nodes and , respectively; see the figure to the right. Here, we use the label of a node to refer to the size of that node as well. Recall that within each stage we iteratively merge the two smallest components, thus, the reason that was merged with before is that none of and are bigger than , that is and . Thus, the size of the grandparent of , which is , is at least . Since the label of has size at most , the doubling process won’t repeat more than times. Thus, the number of edges in is at most (the extra is for the cases when the parity of the number of edges within some stages are odd). Therefore has at most edges. This implies that the height of is . ∎

By Lemma 2, has levels. The labels of the nodes of each level is a partition of a subset of . Accordingly, we have a partition of a subset of with respect to those nodes. Thus, the total number of blue points (resp. red points) in each level is at most (resp. at most ). Therefore, the time we spend per level of to compute all from the Delaunay triangulations of their children is . Lemma 1 can easily be generalized to any partition of any subset of . Based on this, the total size of sets in each level of is . Therefore, the time we spend per level to compute all from the Delaunay triangulations of their children is . It turns out that for each level of we spend time. Therefore, the total running time of algorithm MinBST is .

###### Theorem 1.

Given two disjoint sets and of points in the plane, a Euclidean minimum spanning tree in can be computed in time, where .

## 4 The maximum bichromatic spanning tree problem

In this section we consider the MaxBST problem. Given and , we present an algorithm that computes a MaxBST, in , in time, where . Our algorithm is optimal because fining the bichromatic farthest pair has an lower bound (see [11, Theorem 4.16]). Our MaxBST algorithm is the same as the MinBST algorithm that was presented in Section 3, except, in step 1 we connect each point to a farthest point of opposite color, and in step 2, at each stage of Borůvka’s algorithm, we add the longest red-blue edges connecting each component to a vertex outside of it. The correctness of this algorithm follows from the correctness of Borůvka’s algorithm and the fact that in any maximum bichromatic spanning tree, every point is connected to a farthest point of opposite color. We skip the parts of MaxBST that are similar to MinBST, but describe its core parts that lead to the same running time.

Before analyzing the running time we introduce some notation, and present a lemma that plays an important role in the analysis. For a point set in the plane let denote the list of the vertices of the convex hull of , ordered along the boundary, and let denote the farthest point Voronoi diagram of . Let denote the farthest point Voronoi region/cell of a point in ; notice that has a non-empty Voronoi cell in if and only if is in . For two disjoint point sets and , where each of the points in is colored either red or blue, we define the bichromatic farthest pair as a farthest red-blue pair between and .

###### Lemma 3.

Let and be two disjoint sets of points in the plane, and let be a maximum spanning tree of . Then for every edge with and , is in the convex hull of or is in the convex hull of .

###### Proof.

The proof is by contradiction; take an edge with and , where and . Without loss of generality assume is horizontal, and is to the left of .

Consider two vertical lines and that pass through and , respectively. Since , there is a point that belong to and is to the left of . Similarly, there is a point that belong to and is to the right of . Observe that is smaller than each of , , and . Let and be the two trees obtained from by removing . We consider two cases: (i) and are in different trees, or (ii) and are in a same tree. In case (i) we obtain a tree by joining and with . In case (ii) without loss of generality assume that and are in . Then, we obtain a tree by joining and with . In both cases, is a spanning tree of that is longer than ; this contradicts the optimality of . ∎

###### Observation 2.

Let and be two sets of points in the plane. Then, the longest edge between and has an endpoint in and an endpoint in .

Step 1 in algorithm MaxBST takes time; a straightforward solution is to locate all points of in and all points of in . In the rest of this section we show how to run Borůvka’s algorithm (step 2) in time. Let be the components of the current stage of Borůvka’s algorithm. We have to find for each component , the longest edge connecting a point in to an oppositely-colored point outside of . In fact, we have to solve the following problem:

###### Problem.

Let and be two sets of red and blue points in the plane, respectively. Given a partition of into such that each point is in the same set as its farthest point of opposite color, find for each , the farthest red-blue pair between and , and the farthest red-blue pair between and , i.e., and .

The following algorithm finds for all . By swapping the role of red and blue points, one can compute for all . For the purpose of this algorithm, by Lemma 3, we assume that is in convex position; this can be done by setting to be . This assumption does not violate the fact that each blue point is in the same component as its farthest red point, because the farthest red point to any blue point is in . By Observation 2, the longest edge between and has an endpoint in . Thus, to compute , we maintain and compute instead.

First, we prove the correctness of algorithm All-Blue-BFP. To simplify the notation, we write for . Since is in convex position, every point of has a non-empty Voronoi cell in . The set , that is computed in line 3, contains the points of whose cell in is adjacent to the cell of a point in . Then, in line 5, the algorithm computes as the endpoints of the longest red-blue edge between and , i.e., . Notice that is in convex position. Take any . Let where and . To prove the correctness of this algorithm, we only need to show that is in . In order to show this, we prove that is adjacent to for some point ; this guarantees that algorithm All-Blue-BFP adds to in line 3. Figure 3: p is a point of ¯¯¯¯¯¯Ri that is farthest to b, and r is a point of R that is farthest to b.

Consider the farthest point Voronoi diagram . Because is a point of that is farthest to , lies in , which is a convex region. See Figure 3. Imagine the construction of by inserting the points of to . By inserting these points, the Voronoi cells of do not get larger. Thus, is a subset of , and since is in convex position, is not empty. Recall that ’s farthest red point in , say , is in , and hence lies in . Take a point in . Because of the convexity of , is inside this cell, and thus, no edge of crosses . In , and belong to two different cells. This implies that some edges of cross . Among those edges, consider the edge whose intersection with is closest to . Let be the point such that is the common edge between and . Since by inserting the points of into , the cells of the points of get smaller, the point —which has on its boundary in —belongs to . This finishes the proof for the correctness of All-Blue-BFP.

By a similar reasoning as in the proof of Lemma 1 we show that the total size of the sets is . The number of sets , that a red point belongs to is at most ’s degree in , that is, the number of its Voronoi neighbors. The sum of the degrees, over all points of is at most because has at most edges (or pairs of neighbors). Therefore, the total size of the sets is . Moreover, having , these sets can be computed in time by checking all edges of .

The running time analysis of algorithm All-Blue-BFP is similar to the one for algorithm All-Blue-BCP that we have seen in Section 3. Instead of maintaining Delaunay triangulations, here we maintain convex hulls and farthest point Voronoi diagrams. First, we review some known results. Let and denote two convex polygons in the plane. Aggarwal et al. showed how to compute the farthest point Voronoi diagram of in time. Edelsbrunner  showed that the two vertices that define the maximum distance between and can be computed in time; he also proved the lower bound of for this problem. Assume the vertices of are in convex position. Then, having and , one can merge them to compute in time. The reverse operation can also be done in linear time. That is, one can split to obtain and in time .

Now we analyze the running time of algorithm All-Blue-BFP. It takes time to construct . In the first stage of Borůvka’s algorithm we compute and for all . This takes time because the total size of the sets is , and the total size of the sets is . Having , and for all , we maintain ’s and ’s for the next stage of Borůvka’s algorithm, using similar merge and split operations as in the MinBST algorithm. This maintenance takes time per level of the imaginary tree which has height . Therefore, in total, the algorithm All-Blue-BFP takes time for all stages of Borůvka’s algorithm.

###### Theorem 2.

Given two disjoint sets and of points in the plane, a Euclidean maximum spanning tree in can be computed in time, where .

## 5 The Min-k-ST and Max-k-ST problems

In a multicolored version of the Euclidean minimum spanning tree problem, the input points are colored by at least two colors, and we want the colors of the two endpoints of every edge in the tree to be distinct. Formally, we are given a set of points in the plane that is partitioned into , with . For each , assume the points of are colored . In the bichromatic setting, is . Also, the standard Euclidean minimum spanning tree problem can be interpreted as an instance of this multicolored version in which , i.e., each point has a unique color. Let be the complete multipartite geometric graph on , which has edges between every point of each set in the partition to all points of the other sets. The Min--ST problem is the problem of computing a minimum spanning tree in . We refer to its maximum counterpart as Max--ST. In this section we show how to solve these problems in time. We show this for the Min--ST problem; the solution for the Max--ST problem is analogous.

The algorithm is as follows. Represent each of the colors in binary as a sequence of bits. For each , define two canonical point sets: a point set that contains the points whose color’s th bit is , and a point set that contains the points whose color’s th bit is . Note that is a partition of . In order to compute a Min--ST in , we do the following. First we compute MinBST() for all . This gives spanning trees, each of which has edges (these edges are bichromatic in terms of and ). Construct a graph by taking the union of these spanning trees; has edges. Then, compute a minimum spanning tree of by Prim’s algorithm, and output it as a solution.

The running time analysis of this algorithm is straightforward. Since the construction of MinBST() takes time for each , the total time to compute all MinBSTs is . The running time of Prim’s algorithm on is . Thus, the total running time of the algorithm is . To prove the correctness of the algorithm, it suffices to show that contains an optimal Min--ST of . We show this in the following lemma.

###### Lemma 4.

There exists an optimal Min--ST of that is a subgraph of .

###### Proof.

The proof is constructive.

Take an optimal Min--ST of , say . Let be the set of edges of that are not in . If is empty, then is a subgraph of and we are done. Otherwise, we iteratively replace the edges of , that are in , by some edges of , without increasing the weight of . Take any edge in . Assume is colored and is colored . Since , the binary representations of and differ in at least one bit. Let be such a bit position. Without loss of generality assume that ’s th bit is and ’s th bit is . This implies that and . Let be the tree that is obtained by MinBST(); note that is a spanning subgraph of . Since , . Consider the path between and in . Since is an optimal bichromatic tree between and , none of the edges of is longer than . Let and be the two trees obtained from by removing . There is an edge in such that and connects a point to a point . Let be the tree that is obtained by joining and with . The tree is a valid spanning tree of whose weight is equal or smaller than the weight of . Therefore, is also an optimal Min--ST and the number of edges of that do not belong to is . Set , and repeat this process until . ∎

###### Theorem 3.

Given a set of points in the plane where is partitioned into sets , a Euclidean minimum respectively maximum spanning tree in can be computed in time.

## 6 Open Problem

We presented -time algorithms for the Min--ST and Max--ST problems. Presenting faster algorithms for these problems or providing a matching lower bound is open. Notice that for , these problems can be solved in time.

## References

•  A. Aggarwal, H. Edelsbrunner, P. Raghavan, and P. Tiwari. Optimal time bounds for some proximity problems in the plane. Inf. Process. Lett., 42(1):55–60, 1992.
•  A. Aggarwal, L. J. Guibas, J. B. Saxe, and P. W. Shor. A linear-time algorithm for computing the Voronoi diagram of a convex polygon. Discrete & Computational Geometry, 4:591–604, 1989.
•  D. Avis. Lower bounds for geometric problems. In 18th Allerton Conference, Urbana, IL, pages 35–40, 1980.
•  B. Chazelle, O. Devillers, F. Hurtado, M. Mora, V. Sacristán, and M. Teillaud. Splitting a Delaunay triangulation in linear time. Algorithmica, 34(1):39–46, 2002.
•  B. V. Cherkassky, A. V. Goldberg, and C. Silverstein. Buckets, heaps, lists, and monotone priority queues. SIAM J. Comput., 28(4):1326–1346, 1999.
•  H. Edelsbrunner. Computing the extreme distances between two convex polygons. J. Algorithms, 6(2):213–224, 1985.
•  H. Kaplan, W. Mulzer, L. Roditty, P. Seiferth, and M. Sharir. Dynamic planar Voronoi diagrams for general distance functions and their algorithmic applications. CoRR, abs/1604.03654, 2016.
•  D. G. Kirkpatrick. Efficient computation of continuous skeletons. In 20th Annual Symposium on Foundations of Computer Science, pages 18–27, 1979.
•  M. Löffler and W. Mulzer. Triangulating the square and squaring the triangle: Quadtrees and Delaunay triangulations are equivalent. SIAM J. Comput., 41(4):941–974, 2012.
•  C. L. Monma, M. Paterson, S. Suri, and F. F. Yao. Computing Euclidean maximum spanning trees. Algorithmica, 5(3):407–419, 1990.
•  F. P. Preparata and M. I. Shamos. Computational Geometry - An Introduction. Texts and Monographs in Computer Science. Springer, 1985.
You are adding the first comment!
How to quickly get a good reply:
• Give credit where it’s due by listing out the positive aspects of a paper before getting into which changes should be made.
• Be specific in your critique, and provide supporting evidence with appropriate references to substantiate general statements.
• Your comment should inspire ideas to flow and help the author improves the paper.

The better we are at sharing our knowledge with each other, the faster we move forward.
The feedback must be of minimum 40 characters and the title a minimum of 5 characters   