Distance labeling schemes for trees

# Distance labeling schemes for trees

Stephen Alstrup Department of Computer Science, University of Copenhagen. E-mail: s.alstrup@di.ku.dk.    Inge Li Gørtz DTU Compute, Technical University of Denmark. E-mail: inge@dtu.dk    Esben Bistrup Halvorsen . Department of Computer Science, University of Copenhagen. E-mail: esben@bistruphalvorsen.dk    Ely Porat Department of Computer Science, Bar-Ilan University. porately@cs.biu.ac.il
###### Abstract

We consider distance labeling schemes for trees: given a tree with nodes, label the nodes with binary strings such that, given the labels of any two nodes, one can determine, by looking only at the labels, the distance in the tree between the two nodes.

A lower bound by Gavoille et. al. (J. Alg. 2004) and an upper bound by Peleg (J. Graph Theory 2000) establish that labels must use bits111Throughout this paper we use for .. Gavoille et. al. (ESA 2001) show that for very small approximate stretch, labels use bits. Several other papers investigate various variants such as, for example, small distances in trees (Alstrup et. al., SODA’03).

We improve the known upper and lower bounds of exact distance labeling by showing that bits are needed and that bits are sufficient. We also give ()-stretch labeling schemes using bits for constant . ()-stretch labeling schemes with polylogarithmic label size have previously been established for doubling dimension graphs by Talwar (STOC 2004).

In addition, we present matching upper and lower bounds for distance labeling for caterpillars, showing that labels must have size . For simple paths with nodes and edge weights in , we show that labels must have size .

## 1 Introduction

A distance labeling scheme for a given family of graphs assigns labels to the nodes of each graph in the family such that, given the labels of two nodes in the graph and no other information, it is possible to determine the shortest distance between the two nodes. The labels are assumed to be composed of bits, and the goal is to make the worst-case label size as small as possible. Labeling schemes are also called implicit representation of graphs [60, 67]. The problem of finding implicit representations with small labels for specific families of graphs was introduced in the 1960s [14, 15], and efficient labeling schemes were introduced in [42, 53]. Distance labeling for general graphs has been considered since the 1970/80s [38, 68], and later for various restricted classes of graphs and/or approximate distances, often tightly related to distance oracle and routing problems, see e.g. . This paper focuses on distance labels for the well studied case of trees.

#### Exact distances.

In  Peleg presented an bits distance labeling scheme for general unweighted trees. In  Gavoille et al. proved that distance labels for unweighted binary trees require bits and presented a scheme with bits. This paper presents a scheme of size and further reduces the gap by showing that bits are needed. Our upper bound is a somewhat straightforward application of a labeling scheme for nearest common ancestors [7, 8].

#### Approximate distances.

Let denote the shortest distance between nodes in a tree . An -additive approximation scheme returns a value , where . An -stretched approximation scheme returns a value , where . For trees of height Gavoille et al. [30, theorem 4] gave a 1-additive bit labeling scheme. However, using an extra bit in the label for the node depth modulo 2, it is easy to see that any 1-additive scheme can be made exact. Gavoille et al.  also gave upper and lower bounds of bits for -stretched distance. This paper presents a scheme of size for -stretch for constant . Labeling schemes for -stretch with polylogarithmic size label have previously been given for graphs of doubling dimension  and planar graphs .

#### Distances in caterpillars and paths.

Labeling schemes for caterpillars have been studied for various queries, e.g., adjacency . Here we present upper and lower bounds showing that distance labeling caterpillars requires bits. The upper bound is constructed by reduction to the case of weighted paths with nodes and positive integer edge weights in , for which we give upper and lower bounds showing that labels must have size .

### 1.1 Related work

#### Distances in trees with small height.

It is known that, for unweighted trees with bounded height , labels must have size . The upper bound follows from [30, Theorem 2] and the lower bound from [37, Section 3]222We thank Gavoille for pointing this out.. In  distance labeling for various restricted class of trees, including trees with bounded height, is considered, and in  another distance labeling scheme for unweighted trees using bits is given.

#### Small distances in trees.

Distances in a tree between nodes at distance at most can be computed with labels of size  . In  it is shown that size are needed for labeling schemes supporting both parent and sibling queries. More generally,  shows that, using labels of size , the distance between two nodes can be determined if it is at most for some constant , which is optimal for . In [31, 32] further improvements are given for small distances in trees. For , corresponding to adjacency testing, there is a sequence of papers that improve the second order term, recently ending with  which establishes that bits are sufficient.

#### Various other cases for trees.

Distance labeling schemes for various other cases have been considered, e.g., for weighted trees [30, 37, 57], dynamic trees , and a labeling scheme variation with extra free lookup [48, 49].

#### Exact and approximate distances in graphs.

Distance labeling schemes for general graphs [6, 37, 38, 60, 66, 68] and various restricted graphs exist, e.g., for bounded tree-width, planar and bounded degree , distance-hereditary , bounded clique-width , some non-positively curved plane , interval  and permutation graphs . Approximate distance labeling schemes, both additive and stretched, are also well studied; see e.g., [16, 24, 30, 33, 37, 39, 40, 51, 57, 65]. An overview of distance labeling schemes can be found in .

### 1.2 Second order terms are important

Chung’s solution in  gives labels of size for adjacency labeling in trees, which was improved to in FOCS’02  and in [13, 18, 27, 28, 45] to for various special cases. Finally it was improved to for general trees in FOCS’15 .

A recent STOC’15 paper  improves label size for adjacency in general graphs from  [42, 52] to almost matching an lower bound [42, 52].

Likewise, the second order term for ancestor relationship is improved in a sequence of STOC/SODA papers [2, 3, 10, 28, 29] (and [1, 45]) to , giving labels of size .

Somewhat related, succinct data structures (see, e.g., [22, 25, 26, 54, 55]) focus on the space used in addition to the information theoretic lower bound, which is often a lower order term with respect to the overall space used.

### 1.3 Labeling schemes in various settings and applications

By using labeling schemes, it is possible to avoid costly access to large global tables, computing instead locally and distributed. Such properties are used, e.g., in XML search engines , network routing and distributed algorithms [21, 23, 64, 65], dynamic and parallel settings  [19, 50], graph representations , and other applications [46, 47, 56, 57, 58]. Various computability requirements are sometimes imposed on labeling schemes [2, 42, 46]. This paper assumes the RAM model.

## 2 Preliminaries

#### Trees.

Given nodes in a rooted tree , is an ancestor of and is a descendant of , if is on the unique path from to the root. For a node of , denote by be the subtree of consisting of all the descendants of (including itself). The depth of is the number of edges on the unique simple path from to the root of . The nearest common ancestor (NCA) of two nodes is the unique common ancestor with largest depth. Let denote the nodes on the simple path from to in . The variants and denote the same path without the first and last node, respectively. The distance between and is the number . We set , where is the root of . A caterpillar is a tree whose non-leaf nodes form a path, called the spine.

#### Heavy-light decomposition.

(From .) Let be a rooted tree. The nodes of are classified as either heavy or light as follows. The root of is light. For each non-leaf node , pick one child where is maximal among the children of and classify it as heavy; classify the other children of as light. The apex of a node is the nearest light ancestor of . By removing the edges between light nodes and their parents, is divided into a collection of heavy paths. Any given node has at most light ancestors (see ), so the path from the root to goes through at most heavy paths.

#### Bit strings.

A bit string is a member of the set . We denote the length of a bit string by , the th bit of by , and the concatenation of two bit strings by . We say that is the most significant bit of and is the least significant bit.

#### Labeling schemes.

An distance labeling scheme for trees of size consists of an encoder and a decoder . Given a tree , the encoder computes a mapping assigning a label to each node . The decoder is a mapping , where denotes the positive integers, such that, given any tree and any pair of nodes , . Note that the decoder does not know . The size of a labeling scheme is defined as the maximum label size over all trees and all nodes . If, for all trees , the mapping is injective we say that the labeling scheme assigns unique labels.

## 3 Distances on weighted paths

In this section we study the case of paths with nodes and integral edge weights in . The solution to this problem will later be used to establish the upper bound for caterpillars.

### 3.1 Upper Bound

###### Theorem 3.1.

There exist a distance labeling scheme for paths with nodes and positive integral edge weights in with labels of size .

###### Proof.

We begin by considering the family of paths with nodes, integral edge weights and diameter . We shall prove that there exists a distance labeling scheme for this family with labels of size .

So consider such a path, and root it in one of its end nodes, denoted . Denote the nodes on the path in order. Let and note that, by assumption, for all . We will let the label for store the number for some that allows us to represent compactly. Since we use the same for all nodes, we can easily compute the distance between any pair of nodes as .

Since we choose , the largest number stored in a label will be , which can be represented with exactly bits. Divide those bits to segments, whereof have bits and the last segment contains the remaining bits. The first segment, segment , will contain the least significant bits, segment the following bits and so on. We will choose such that the representation of has s in all the bits in the ’th segment. If we manage to do so, we will be able to encode each with bits. Indeed, we can use exactly bits to represent , and the next bits to represent where we skip the ’th segment. Prefixing with a string in the form , we get a string from which we can determine the number of bits needed to write and therefrom the numbers and . We use this string as the label for . The label length is .

It remains to show that there exist a number as described. In the following we shall, as in the above, represent numbers with bits that are divided into segments whereof the first have size . For and , let be a function which returns a number with the following properties:

• In , all bits outside segment are .

• has only s in segment .

This function is constructed as follows. If only has s in segment , let . Otherwise take the representation of , zero out all bits outside segment , reverse the bits in segment and add to the resulting number, where has a 1 in the least significant bit of segment and 0s in all other positions.

Note that from (i) it follows that adding to any number will not change bits in less significant positions than segment . We can now scan through the nodes , increasing by adding bits to in more and more significant positions (in non-overlapping segments), as follows:

• Set .

• For , set .

After iteration we have that in segment only has 0s, and in the following iterations, s are only added to in more significant bit positions, meaning that continues to have only s in segment . Since the segments are non-overlapping, we end up with .

For the more general family of paths with nodes and edge weights in , we simply note that the diameter of any path in this family is at most . Using the above result thus immediately gives us a labeling scheme with labels of size . ∎

### 3.2 Lower bound

###### Theorem 3.2.

Labeling scheme for distances on weighted paths with nodes and edge weights require bits.

###### Proof.

Let denote the family of paths with nodes and integral edge weights in . We can construct all the members of by selecting different edge weights in the range , skipping the paths which have already been constructed by the reverse sequence of edge weights. With this construction we will at most skip half of the paths, and hence . Let the worst-case label size of an optimal distance labeling scheme for such paths have length . The number of different labels with length at most is . We can uniquely represent each of the paths in with the collection of their labels, and hence . Thus, we have found that . Since , it follows that and hence that as desired.

Combining Theorem 3.2 with Theorem 3.1 we see that distance labels for paths of nodes with integral weights in must have length .

## 4 Distances in caterpillars

### 4.1 Upper bound

###### Theorem 4.1.

There exist a distance labeling scheme for caterpillars with worst case label size .

###### Proof.

We will start by giving a simple bits scheme and then improve it. The simple solution assigns two numbers to each node. The nodes on the spine save and the number . The nodes not on the spine save their parent’s and a number that is unique among their siblings. The second number is required to distinguish siblings, and hence determine if the distance between two nodes is or . The worst-case label size for this solution is .

To improve the solution, we split up the nodes on the spine into two groups: (1) nodes with leaves and (2) nodes with leaves, for some parameter to be chosen later. We add the root to the first group no matter what. Note that the first group can contain at most nodes.

As before, all nodes save two numbers: and the number for spine nodes or a number to distinguish siblings. The idea is to reduce label size with bits by using fewer bits for the first number for nodes in the first group and for the second number for nodes in the second group.

The nodes in the first group form a path with at most nodes and edge weights in (where each weight corresponds to the distance between the nodes in the original graph). The algorithm from Theorem 3.1 will add a number , which is less than the diameter, which again is less than , to the numbers representing the root distances of the nodes. Using this technique, we can, as seen in the proof of Theorem 3.1, encode the (modified) s of the nodes in the first group with only bits. This gives labels of size for non-spine nodes whose parents are in the first group.

We will also add to the s of nodes in the second group, but since this will not change the label size by more than a single bit. For non-spine nodes whose parents are in the second group, we need at most bits for the second number, giving a total label size of .

Finally, since the two numbers that form a label now have different lengths, we need an additional bits to determine when one number ends and the next begins. Indeed, it wil be possible to split up labels into their components if we know the number of bits used to write , and we represent this number with bits.

Setting , we now see that our worst-case label size is the maximum of

 2logn−logk+O(loglogk)=2logn−loglogn+O(logloglogn)

and

 2k−1klogn+logk+O(loglogk) =2logn−2loglogn+loglogn+O(logloglogn) =2logn−loglogn+O(logloglogn).

This proves the theorem. ∎

### 4.2 Lower bound

We present a technique that counts tuples of labels that are known to be distinct and compares the result to the number of tuples one can obtain with labels of size . The technique may have applications to distance labeling for other families of graphs.

###### Theorem 4.2.

For any , any distance labeling scheme for the family of caterpillars with at most nodes has a worst-case label size of at least .

###### Proof.

Set and . Let be a sequence of numbers from the set with the only requirement being that . Now consider, for each such sequence, the caterpillar whose main path has length and where, for , the node in position has leaf children (not on the main path). We shall refer to these children as the ’th group. Note that two disjoint groups of children may be children of the same node if for some . Each of these caterpillar has nodes.

Suppose that is a distance labeling scheme for the family of caterpillars, and consider one of the caterpillars defined above. Given distinct nodes not on the main path, their distance will be , where and are the positions on the main path of the parents of and , respectively. In particular, if , so that , then . Thus, if has been used to label the nodes of the caterpillar, the number for a child in the ’th group can be uniquely determined from its label together with the label of any of the children from the first group. It follows that any -tuple of labels where is a label of a child in the ’th group uniquely determines the sequence . In particular, -tuples of labels from distinct caterpillars must be distinct. Of course, -tuples of labels from the same caterpillar must also be distinct, since labels are unique in a distance labeling scheme.

Now, there are choices for the sequence , and hence there are different caterpillars in this form. For each of these, there are different choices of -tuples of labels. Altogether, we therefore have distinct -tuples of labels. If the worst-case label size of is , then we can create at most distinct -tuples of labels, so we must have . From this it follow that

 L ≥⌊k−1k(logm−1)+log⌊m/2k⌋⌋ ≥⌊(k−1)2k+k−logk⌋−2 ≥2k−⌊logk⌋−4 =2⌊logn⌋−⌊log⌊logn⌋⌋−4.\qed

## 5 Exact distances in trees

### 5.1 Upper bound

Let be nodes in a tree and let be their nearest common ancestor. We then have

 dist(u,v)=distroot(u)−distroot(v)+2dist(w,v) (1)

If so that is an ancestor of , then the above equation is just a difference of distroots, which can be stored for each node with bits. The same observation clearly holds if .

Assume now that so that and are not ancestors of each other. Consider the heavy-light decomposition  described in the preliniaries. At least one of the nodes and must have an ancestor which is a light child of . Assume that it is . Now, has at most light ancestors. Saving the distance to all of them together with gives us sufficient information to compute the distance between and using equation (1). This is the idea behind Theorem 5.2 below.

By examining the NCA labeling scheme from [7, 8], we see that it can easily be extended as follows.

###### Lemma 5.1 ([7, 8]).

There exists an NCA labeling scheme of size . For any two nodes the scheme returns the label of as well as:

• which of and (if any) have a light ancestor that is a child of ; and

• the number of light nodes on the path from the root to and from to and , respectively.

###### Theorem 5.2.

There exists a distance labeling scheme for trees with worst-case label size .

###### Proof.

We use bits for the extended NCA labeling in Lemma 5.1 and for . Using (1) it now only remains to efficiently represent, for each node, the distance to all its light ancestors. We consider the light ancestors of a node encountered on the path from the root to . The distance from to the root is at most and can therefore be encoded with exactly bits (by adding leading zeros if needed). By construction of the heavy-light decomposition, the next light node on the path to will be the root of a subtree of size at most , meaning that the distance from to that ancestor is at most and can be encoded with exactly bits. Continuing this way, we encode the ’th light ancestor on the path from the root to with exactly bits. When we run out of light ancestors, we concatenate all the encoded distances, resulting in a string of length at most

 ⌈logn⌉+(⌈logn⌉−1)+⋯+2+1=12⌈logn⌉2+12⌈logn⌉.

We can use extra bits to encode and to separate all sublabels from each other. The decoder can now determine and split up the entries in the list of distances. When applying formula (1), it can then determine the distance between and by adding together the relevant distances in the list of light ancestors, using the fact from Lemma 5.1 that it knows the number of light ancestors from to . ∎

### 5.2 Lower bound

In the case of general trees, Gavoille et al  establish a lower bound of using an ingenious technique where they apply a distance labeling scheme to a special class of trees called -trees333Note that their exposition has some minor errors as pointed out (and corrected) in . The following uses a generalization of -trees to improve their ideas and leads to a lower bound of .

#### (h,W,a)-trees.

We begin with some definitions. For integers and a number such that is integral for all , an -tree is a rooted binary tree with edge weights in that is constructed recursively as follows. For , is just a single node. For , is a claw (i.e. a star with three edges) with edge weights for some rooted at the leaf node of the edge with weight . For , consists of an -tree whose two leaves are the roots of two -trees . We shall denote an -tree constructed in this way by An example for can be seen in Figure 1. Note that the case simply corresponds to the -trees defined in .

It is easy to see that an -tree has leaves and nodes. Further, it is straightforward to see that, if are leaves in an -tree , then

 distT(u,v)={2Wa−1−a−h1−a−1+2x,if u∈T0 and v∈T1, or vice versa,distTi(u,v),if u,v∈Ti for some i=0,1. (2)

#### Leaf distance labeling schemes.

In the following we shall consider leaf distance labeling schemes for the family of -trees: that is, distance labeling schemes where only the leaves in a tree need to be labeled, and where only leaf labels can be given as input to the decoder. Since an ordinary distance labeling scheme obviously can be used only for leaves, any lower bound on worst-case label sizes for a leaf distance labeling scheme is also a lower bound for an ordinary distance labeling scheme. We denote by the smallest number of labels needed by an optimal leaf distance labeling scheme to label all -trees.

For all and , .

###### Proof.

Fix an optimal leaf distance labeling scheme which produces exactly distinct labels for the family of -trees. For leaves and in an -tree, denote by and , respectively, the labels assigned by . For , let be the set consisting of pairs of labels for all leaves and in all -trees .

The sets and are disjoint for , since every pair of labels in uniquely determines due to (2). Letting , we therefore have . Since contains pairs of labels produced by from leaves in -trees , we clearly also have , and hence it only remains to prove that , which we shall do by showing that for all .

The goal for the rest of the proof is therefore to create a leaf distance labeling scheme for -trees using only labels from the set for some fixed . So let be given and consider an -tree . Let . From we shall construct an -tree for such that every leaf node in corresponds to nodes in for . The trees are defined as follows. If , so that consists of a single node, then for . If , then is in the form for some . We can write in the form for uniquely determined with . For , we recursively define . Thus, is an -tree that is similar to but where we replace the top edge weight by edge weights and, recursively, do the same for all -subtrees. Note also that the corresponding edge weight in automatically is replaced by the edge weight in in order for to be an -tree.

Denote by the leaf in corresponding to the leaf in .

Consider now the -tree . Every leaf in corresponds to the leaves in where for . Using formula (2) for the distances in , it is straightforward to see that

 distT′(u,v)=(distϕ0(T′)(ϕ0(u),ϕ0(v))mod(2V))+Vdistϕ1(T′)(ϕ1(u),ϕ1(v)).

We can now apply the leaf distance labeling scheme to and obtain a label for each leaf node in . In particular, the pair of leaves corresponding to a node in will receive a pair of labels. We use this pair to label in , whereby we have obtained a labeling of the leaves in with labels from . Using the formula in (5.2) we can construct a decoder that can compute the distance between two nodes in using these labels alone, and hence we have obtained a leaf distance labeling scheme for -trees using only labels from as desired. ∎

For all and , .

###### Proof.

The proof is by induction on . For we note that an -tree has only one node, so that . Lemma 5.3 therefore yields from which it follows that . The lemma therefore holds for . Now let and assume that the lemma holds for . Lemma 5.3 and the induction hypothesis now yield

 g(h,W,a)2 ≥Wg(h−1,W2/a2,a2) ≥W(W2/a2)(h−1)/2a2(h−1)(h−2)/4 =Whah(h−1)/2

from which it follows that as desired. ∎

The previous lemma implies that any (leaf and hence also ordinary) distance labeling scheme for -trees must have labels with worst-case length at least . Since the number of nodes in such a tree is , it follows that , and hence that for sufficiently large . From this we see that the worst case label length is at least

 12lognlogW−14logn(logn−1)loga−logW−12loga.

In the case where , we retrieve the bound of obtained in . It seems that larger values of only makes the above result weaker, but the the real strength of the above becomes apparent when we switch to the unweighted version of -trees, in which we replace weighted edges by paths of similar lenghts. Note that a distance labeling scheme for the family of unweighted -trees can be used as a distance labeling scheme for the weighted -trees, and hence any lower bound in the weighted version automatcially becomes a lower bound in the unweighted version.

The number of nodes in an unweighted -tree is upper bounded by

 n≤2W+2⋅2W/a+22⋅2W/a2+⋯+2h−1⋅2W/ah−1+1

In the case , we get .

###### Theorem 5.5.

Any distance labeling scheme for unweighted -trees, and hence also for general trees, has a worst-case label size of at least .

###### Proof.

Choose the largest integer with , and note that we must have . Set and consider the family of -trees, which is a subfamily of the family of trees with nodes. From Lemma 5.4 it therefore follows that the worst-case label length is

 12hlogW−14h2+14h =14h2+14h=14log2n+14logn−O(loglogn).\qed

## 6 Approximate distances in trees

In this section we present a -stretch distance labeling schemes with labels of size .

###### Theorem 6.1.

For constant , stretch labeling scheme use bits.

###### Proof.

As in the case of exact distances, we will create labels of size bits that contain the extended NCA labels from Lemma 5.1 as well as . We will also be using the formula in (1). However we can not afford to store exact distance to each apex ancestor. Even storing an -approximate distance to each apex ancestor would require bits. Furthermore, given approximate distance to the apex nodes does not directly guarantee upper bound for the approximate distance, as we in equation (1) are using subtractions. We will in the following address these two problems.

Let and assume , since otherwise we can compute the exact distance using only . Suppose we know a -approximation of for some . That is,

 dist(w,v)≤α≤(1+ε)dist(w,v). (3)

Define . First we show that is a -approximation of . Next we show how to represent all the -approximate distances to light ancestors for a node using a total of bits. Together with formula (1), these two facts prove that we can compute -stretch distances between any pair of nodes with labels of size . To prove the theorem, we can then simple replace by .

To see that is a -approximation of , first note that

 ~d=distroot(u)−distroot(v)+2α≥distroot(u)−distroot(v)+2dist(w,v)=dist(u,v).

For the other inequality, note that

 ~d = distroot(u)−distroot(v)+2α ≤ distroot(u)−distroot(v)+2(1+ϵ)dist(w,v) = distroot(u)−(distroot(v)−dist(w,v))+(1+2ϵ)dist(w,v) = distroot(u)−distroot(w)+(1+2ϵ)dist(w,v) = dist(u,w)+(1+2ϵ)dist(w,v) ≤ (1+2ϵ)(dist(u,w)+dist(w,v)) = (1+2ϵ)dist(u,v).

It now only remains to show that we can compactly store all the approximate distances to light ancestors using bits space.

We use a heavy light path decomposition of the tree. For each node we can save a approximate distance to all its proper light ancestors node as follows. Let be a binary string initially with zeros. Before each we now inserts s such that, if we have s in total from the beginning of and to the ’th , then the distance to the th light ancestor of satisfies that . This is the same as traversing the tree bottom-up from and, for each light node encountered on the way, adding a and each time the distance doubles adding a . The number of s equal the number of light nodes which is at most , and the number of s is also limited by since is the maximum distance in the tree. In total the length of is at most .

Using the bits label from Lemma 5.1 we can tell if one node is an ancestor of another, and if not which one has a light ancestor that is a child of their nearest common ancestor . In addition, we can determine the total number of light ancestors up to . This means that we can compute , and hence the 2-approximation , as the number of ’s in until the ’th .

We have now obtained a 2-approximation with labels of size . We can improve this to a -approximation by setting a in each time the distance increases with rather than . This will increase the label size with a constant factor .

This proves that there is a -stretch distance labeling scheme with . To complete the proof of the theorem, we note that, given any -stretch distance scheme, we can always distinguish nodes (since identical nodes have distance 0), which means that we always need at least different labels, and hence labels of size at least bits. ∎

## References

•  S. Abiteboul, S. Alstrup, H. Kaplan, T. Milo, and T. Rauhe. Compact labeling scheme for ancestor queries. SIAM J. Comput., 35(6):1295–1309, 2006.
•  S. Abiteboul, H. Kaplan, and T. Milo. Compact labeling schemes for ancestor queries. In Proc. of the 12th Annual ACM-SIAM Symp. on Discrete Algorithms (SODA), pages 547–556, 2001.
•  S. Alstrup, P. Bille, and T. Rauhe. Labeling schemes for small distances in trees. In Proc. of the 14th Annual ACM-SIAM Symp. on Discrete Algorithms (SODA), pages 689–698, 2003.
•  S. Alstrup, P. Bille, and T. Rauhe. Labeling schemes for small distances in trees. SIAM J. Discrete Math., 19(2):448–462, 2005. See also SODA’03.
•  S. Alstrup, S. Dahlgaard, and M. B. T. Knudsen. Optimal induced universal graphs and labeling schemes for trees. In Proc. 56th Annual Symp. on Foundations of Computer Science (FOCS), 2015.
•  S. Alstrup, C. Gavoile, E. B. Halvorsen, and H. Petersen. Simpler, faster and shorter labels for distances in graphs. Submitted, 2015.
•  S. Alstrup, C. Gavoille, H. Kaplan, and T. Rauhe. Nearest common ancestors: A survey and a new algorithm for a distributed environment. Theory of Computing Systems, 37(3):441–456, May 2004.
•  S. Alstrup, E. B. Halvorsen, and K. G. Larsen. Near-optimal labeling schemes for nearest common ancestors. In Proc. of the 25th Annual ACM-SIAM Symp. on Discrete Algorithms (SODA), pages 972–982, 2014.
•  S. Alstrup, H. Kaplan, M. Thorup, and U. Zwick. Adjacency labeling schemes and induced-universal graphs. In Proc. of the 47th Annual ACM Symp. on Theory of Computing (STOC), 2015.
•  S. Alstrup and T. Rauhe. Improved labeling schemes for ancestor queries. In Proc. of the 13th Annual ACM-SIAM Symp. on Discrete Algorithms (SODA), 2002.
•  S. Alstrup and T. Rauhe. Small induced-universal graphs and compact implicit graph representations. In Proc. 43rd Annual Symp. on Foundations of Computer Science (FOCS), pages 53–62, 2002.
•  F. Bazzaro and C. Gavoille. Localized and compact data-structure for comparability graphs. Discrete Mathematics, 309(11):3465–3484, 2009.
•  N. Bonichon, C. Gavoille, and A. Labourel. Short labels by traversal and jumping. In Structural Information and Communication Complexity, pages 143–156. Springer, 2006. Include proof for binary trees and caterpillars.
•  M. A. Breuer. Coding the vertexes of a graph. IEEE Trans. on Information Theory, IT–12:148–153, 1966.
•  M. A. Breuer and J. Folkman. An unexpected result on coding vertices of a graph. J. of Mathemathical analysis and applications, 20:583–600, 1967.
•  V. D. Chepoi, F. F. Dragan, B. Estellon, M. Habib, and Y. Vaxès. Diameters, centers, and approximating trees of delta-hyperbolic geodesic spaces and graphs. In 24st Annual ACM Symp. on Computational Geometry (SoCG), pages 59–68, 2008.
•  V. D. Chepoi, F. F. Dragan, and Y. Vaxès. Distance and routing labeling schemes for non-positively curved plane graphs. J. of Algorithms, 61(2):60–88, 2006.
•  F. R. K. Chung. Universal graphs and induced-universal graphs. J. of Graph Theory, 14(4):443–454, 1990.
•  E. Cohen, H. Kaplan, and T. Milo. Labeling dynamic XML trees. SIAM J. Comput., 39(5):2048–2074, 2010.
•  B. Courcelle and R. Vanicat. Query efficient implementation of graphs of bounded clique-width. Discrete Applied Mathematics, 131:129–150, 2003.
•  L. J. Cowen. Compact routing with minimum stretch. J. of Algorithms, 38:170–183, 2001. See also SODA’91.
•  Y. Dodis, M. Pǎtraşcu, and M. Thorup. Changing base without losing space. In Proc. of the 42nd Annual ACM Symp. on Theory of Computing (STOC), pages 593–602, 2010.
•  T. Eilam, C. Gavoille, and D. Peleg. Compact routing schemes with low stretch factor. J. of Algorithms, 46(2):97–114, 2003.
•  M. Elkin, A. Filtser, and O. Neiman. Prioritized metric structures and embedding. In Proc. of the 47th Annual ACM Symp. on Theory of Computing (STOC), pages 489–498, 2015.
•  A. Farzan and J. I. Munro. Succinct encoding of arbitrary graphs. Theoretical Computer Science, 513:38–52, 2013.
•  A. Farzan and J. I. Munro. A uniform paradigm to succinctly encode various families of trees. Algorithmica, 68(1):16–40, 2014.
•  P. Fraigniaud and A. Korman. On randomized representations of graphs using short labels. In Proc. of the 21st Annual Symp. on Parallelism in Algorithms and Architectures (SPAA), pages 131–137, 2009.
•  P. Fraigniaud and A. Korman. Compact ancestry labeling schemes for XML trees. In Proc. of the 21st annual ACM-SIAM Symp. on Discrete Algorithms (SODA), pages 458–466, 2010.
•  P. Fraigniaud and A. Korman. An optimal ancestry scheme and small universal posets. In Proc. of the 42nd Annual ACM Symp. on Theory of Computing (STOC), pages 611–620, 2010.
•  C. Gavoille, M. Katz, N. Katz, C. Paul, and D. Peleg. Approximate distance labeling schemes. In Proc. of the 9th Annual European Symp. on Algorithms (ESA), pages 476–488, 2001.
•  C. Gavoille and A. Labourel. Distributed relationship schemes for trees. In 18th International Symp. on Algorithms and Computation (ISAAC), pages 728–738, 2007.
•  C. Gavoille and A. Labourel. On local representation of distances in trees. In Proc. of the 26th Annual ACM Symp. on Principles of Distributed Computing (PODC), pages 352–353, 2007.
•  C. Gavoille and O. Ly. Distance labeling in hyperbolic graphs. In 16th Annual International Symp. on Algorithms and Computation (ISAAC), pages 1071–1079, 2005.
•  C. Gavoille and C. Paul. Distance labeling scheme and split decomposition. Discrete Mathematics, 273(1-3):115–130, 2003.
•  C. Gavoille and C. Paul. Optimal distance labeling for interval graphs and related graphs families. SIAM J. Discrete Math., 22(3):1239–1258, 2008.
•  C. Gavoille, D. Peleg, S. Pérennes, and R. Raz. Distance labeling in graphs. In Proc. of the 12th Annual ACM-SIAM Symp. on Discrete algorithms (SODA), pages 210–219, 2001.
•  C. Gavoille, D. Peleg, S. Pérennes, and R. Raz. Distance labeling in graphs. J. of Algorithms, 53(1):85 – 112, 2004. See also SODA’01.
•  R. L. Graham and H. O. Pollak. On embedding graphs in squashed cubes. In Lecture Notes in Mathematics, volume 303. Springer-Verlag, 1972.
•  A. Gupta, R. Krauthgamer, and J. R. Lee. Bounded geometries, fractals, and low-distortion embeddings. In 44th Annual Symp. on Foundations of Computer Science (FOCS), pages 534–543, 2003.
•  A. Gupta, A. Kumar, and R. Rastogi. Traveling with a pez dispenser (or, routing issues in mpls). SIAM J. on Computing, 34(2):453–474, 2005. See also FOCS’01.
•  E. B. Halvorsen. Labeling schemes for trees - overview and new results. Master’s thesis, University of Copenhagen, 2013. Available at esben.bistruphalvorsen.dk.
•  S. Kannan, M. Naor, and S. Rudich. Implicit representation of graphs. SIAM J. Disc. Math., pages 596–603, 1992. See also STOC’88.
•  M. Kao, X. Li, and W. Wang. Average case analysis for tree labelling schemes. Theor. Comput. Sci., 378(3):271–291, 2007.
•  H. Kaplan and T. Milo. Short and simple labels for distances and other functions. In 7nd Work. on Algo. and Data Struc., 2001.
•  H. Kaplan, T. Milo, and R. Shabo. A comparison of labeling schemes for ancestor queries. In Proc. of the 13th Annual ACM-SIAM Symp. on Discrete Algorithms (SODA), 2002.
•  M. Katz, N. A. Katz, A. Korman, and D. Peleg. Labeling schemes for flow and connectivity. SIAM J. Comput., 34(1):23–40, 2004. See also SODA’02.
•  A. Korman. Labeling schemes for vertex connectivity. ACM Trans. Algorithms, 6(2):39:1–39:10, 2010.
•  A. Korman and S. Kutten. Labeling schemes with queries. CoRR, abs/cs/0609163, 2006.
•  A. Korman and S. Kutten. Labeling schemes with queries. In SIROCCO, pages 109–123, 2007.
•  A. Korman and D. Peleg. Labeling schemes for weighted dynamic trees. Inf. Comput., 205(12):1721–1740, 2007.
•  R. Krauthgamer and J. R. Lee. Algorithms on negatively curved spaces. In 47th Annual Symp. on Foundations of Computer Science (FOCS), pages 119–132, 2006.
•  J. W. Moon. On minimal -universal graphs. Proc. of the Glasgow Mathematical Association, 7(1):32–33, 1965.
•  J. H. Müller. Local structure in graph classes. PhD thesis, Georgia Institute of Technology, 1988.
•  J. I. Munro, R. Raman, V. Raman, and S. Srinivasa Rao. Succinct representations of permutations and functions. Theor. Comput. Sci., 438:74–88, 2012.
•  M. Pǎtraşcu. Succincter. In Proc. 49th Annual Symp. on Foundations of Computer Science (FOCS), pages 305–313, 2008.
•  D. Peleg. Informative labeling schemes for graphs. In Proc. 25th Symp. on Mathematical Foundations of Computer Science, pages 579–588, 2000.
•  D. Peleg. Proximity-preserving labeling schemes. J. Graph Theory, 33(3):167–176, 2000.
•  N. Santoro and R. Khatib. Labeling and implicit routing in networks. The computer J., 28:5–8, 1985.
•  D. D. Sleator and R. E. Tarjan. A data structure for dynamic trees. J. of Computer and System Sciences, 26(3):362 – 391, 1983.
•  J. P. Spinrad. Efficient Graph Representations, volume 19 of Fields Institute Monographs. AMS, 2003.
•  K. Talwar. Bypassing the embedding: algorithms for low dimensional metrics. In Proc. of the 36th Annual ACM Symp. on Theory of Computing (STOC), pages 281–290, 2004.
•  M. Tang, J. Yang, and G. Zhang. A compact distance labeling scheme for trees of small depths. In International Conference on Scalable Computing and Communications / Eighth International Conference on Embedded Computing, ScalCom-EmbeddedCom, pages 455–458, 2009.
•  M. Thorup. Compact oracles for reachability and approximate distances in planar digraphs. J. ACM, 51(6):993–1024, 2004. See also FOCS’01.
•  M. Thorup and U. Zwick. Compact routing schemes. In Proc. of the 13th Annual ACM Symp. on Parallel Algorithms and Architectures, SPAA ’01, pages 1–10, 2001.
•  M. Thorup and U. Zwick. Approximate distance oracles. J. of the ACM, 52(1):1–24, 2005. See also STOC’01.
•  O. Weimann and D. Peleg. A note on exact distance labeling. Inf. Process. Lett., 111(14):671–673, 2011.
•  Wikipedia. Implicit graph — wikipedia, the free encyclopedia, 2013. [Online; accessed 15-February-2014].
•  P. M. Winkler. Proof of the squashed cube conjecture. Combinatorica, 3(1):135–139, 1983.
Comments 0
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 Loading ...
362724 You are asking your first question!
How to quickly get a good answer:
• Keep your question short and to the point
• Check for grammar or spelling errors.
• Phrase it like a question Test
Test description