Round-Message Trade-Off in Distributed Steiner Tree Construction in the CONGEST Model

Abstract

The Steiner tree problem is one of the fundamental optimization problems in distributed graph algorithms. Recently Saikia and Karmakar [27] proposed a deterministic distributed algorithm for the Steiner tree problem that constructs a Steiner tree in $O(S + \sqrt{n} \log ^* n)$ rounds whose cost is optimal upto a factor of $2(1 - 1/\ell )$, where n and S are the number of nodes and shortest path diameter [17] respectively of the given input graph and $\ell$ is the number of terminal leaf nodes in the optimal Steiner tree. The message complexity of the algorithm is $O(\varDelta (n - t) S + n^{3/2})$, which is equivalent to $O(mS + n^{3/2})$, where $\varDelta$ is the maximum degree of a vertex in the graph, t is the number of terminal nodes (we assume that $t < n$), and m is the number of edges in the given input graph. This algorithm has a better round complexity than the previous best algorithm for Steiner tree construction due to Lenzen and Patt-Shamir [21]. In this paper we present a deterministic distributed algorithm which constructs a Steiner tree in $\tilde{O}(S + \sqrt{n})$ rounds and $\tilde{O}(mS)$ messages and still achieves an approximation factor of $2(1 - 1/\ell )$. Note here that $\tilde{O}(\cdot )$ notation hides polylogarithmic factors in n. This algorithm improves the message complexity of Saikia and Karmakar’s algorithm by dropping the additive term of $O(n^{3/2})$ at the expense of a logarithmic multiplicative factor in the round complexity. Furthermore, we show that for sufficiently small values of the shortest path diameter $(S=O(\log n))$, a $2(1 - 1/\ell )$-approximate Steiner tree can be computed in $\tilde{O}(\sqrt{n})$ rounds and $\tilde{O}(m)$ messages and these complexities almost coincide with the results of some of the singularly-optimal minimum spanning tree (MST) algorithms proposed in [9, 12, 23].

Appendices

A Elkin’s Algorithm [9]

This algorithm starts with the construction of an auxiliary BFS tree $T_B$ rooted at some root node r. It consists of two parts. The first part constructs an (O(n/D), O(D))-MST forest⁵ which is termed as the base MST forest. In the second part, the algorithm in [23] is applied on top of the base MST forest to construct the final MST. Specifically in the second part, the Boruvka’s algorithm is applied in such a way that merging of any two fragments requires O(D) rounds.

The first part of the algorithm runs for $\lceil \log D \rceil$ phases. At the beginning of a phase i, (i varies from 0 to $\lceil \log D \rceil - 1$), the algorithm computes $(n/2^{i - 1}, O(2^i))$-MST forest ($\mathcal {F}_i$). Each node updates its neighbors with the identity of its fragment. This requires O(1) rounds and O(m) messages. Every fragment $F \in \mathcal {F}_i$ of diameter $O(2^i)$ computes the MWOE $e_F$. For each $e_F = (u, v)$, $u \in V(F)$, $v \in V \setminus V(F)$, a message is sent over $e_F$ by u and the receiver v notes down u as a foreign-fragment child of itself. In case the edge (u, v) is the MWOE for both the neighboring fragments $F_u$ and $F_v$, the endpoint with the higher identity fragment becomes the parent of the other endpoint. This defines a candidate fragment graph $\mathcal {G}_i' = (\mathcal {F}_{i}', \mathcal {E}_i)$, where $\mathcal {F}_{i}'$ is the set of fragments whose diameter is $O(2^i)$ and each such fragment is considered as a vertex of $\mathcal {G}_i'$ and $\mathcal {E}_i$ is the set of MWOE edges of all the fragments in $\mathcal {F}_{i}'$. The computation of the candidate fragment graph $\mathcal {G}_i'$ requires $O(2^i)$ rounds and O(n) messages. Then a maximal matching of $\mathcal {G}_i'$ is built by using the Cole-Vishkin’s 3-vertex coloring algorithm [7]. The computation of a maximal matching of $\mathcal {G}_i'$ requires $O(2^i \cdot \log ^* n)$ rounds and $O(n \cdot \log ^* n)$ messages. The phase i ends at the computation of a maximal matching of the candidate fragment graph $\mathcal {G}_i'$. Hence the running time of a phase i is $O(2^i \cdot \log ^* n)$ which requires $O(m + n \cdot \log ^* n)$ messages. Since the first part runs for $\lceil \log D \rceil$ phases, the overall time and message complexities to construct a base MST forest are $O(D\cdot \log ^* n)$ and $O(m \log D + n \log D \cdot \log ^* n)$ respectively.

In the second part, the algorithm in [23] is applied on the top of the (O(n/D), O(D))-MST forest ($\mathcal {F}$). This part maintains two forests: one is the base MST forest $\mathcal {F}$ which is already computed in the first part of the algorithm and the other one is the MST forest $\hat{\mathcal {F}}$ obtained by merging some of the base fragments into the fragments of $\hat{\mathcal {F}}$ via Boruvka’s algorithm. The second part of the algorithm requires $O(\log n)$ phases. In any phase $j+1$, it does the following. In every base fragment $F \in \mathcal {F}$, the MWOE $e = (u, v)$ is computed (in parallel in all base fragments) that crosses between $u \in V(F)$ and $v \in V \setminus V(\hat{F})$, where $\hat{F} \in \mathcal {F}_j$ is the larger fragment that contains F. This step requires O(D) rounds and O(n) messages. Once all O(n/D) MWOEs are computed, all of these information are sent to r of $T_B$. This is done using pipelined convergecast procedure over $T_B$, in which each vertex u of $T_B$ forwards to its parent in $T_B$ the lightest edge for each fragment $\hat{F} \in \mathcal {F}_j$. This step requires $O(D + |\mathcal {F}_j|)$ rounds and $O(D \cdot |\mathcal {F}_j|)$ messages. Then the root node r does the following: (i) computes MWOE $e_{\hat{F}}$ for every $\hat{F} \in \mathcal {F}_j$, (ii) computes a graph whose vertices are fragments of $\mathcal {F}_j$ and edges are the MWOEs, and (iii) computes the MST forest $\mathcal {F}_{j + 1}$. After that r sends $|\mathcal {F}|$ messages over $T_B$ using pipelined broadcast where each message is of the form $(F, \hat{F}')$, and $F \in \mathcal {F}$ and $\hat{F}' \in \mathcal {F}_{j + 1}$. The root $r_F$ of the base fragment F (each base fragment has a root node) receives this information $(F, \hat{F}')$ and broadcasts the identity of $\hat{F}'$ as the new fragment identity to all the vertices of F. This takes O(D) rounds and O(n) messages. Finally each vertex v updates its neighbors in G with the new fragment identity. This requires O(1) rounds and O(m) messages. Combining both the parts, the overall round and message complexities of Elkin’s algorithm are $O((D + \sqrt{n}) \log n)$ and $O(m \log n + n \log n \cdot \log ^* n)$ respectively.

B Pseudocode for the SPF Algorithm

Let Z be the set of terminals, U be the set of $\langle update \rangle$ messages received by node v in a round, $\delta (v)$ denotes the set of edges incident on a node v, SN(v) denotes the state of a node v (which can be either $active$ or $sleeping$), $t\pi (v)$ denotes the tentative predecessor of v, tf(v) denotes the $terminal\_flag$ of v (which can be either true or false), and ES(e) denotes the state of an edge e (which can be either $basic$ or $blocked$).