A Survey on Streaming Algorithms for Massive Graphs 397 Other variants of the streaming model also exist. For example, the W-stream model [15] allows the algorithm to write to (annotate) the stream during each pass. These annotations can then be utilized by the algorithm in the successive passes. Another variant [1] augments the streaming model by adding a sorting primitive. 3. Statistics and Counting Triangles In this section, we describe a set of problems that involve graphs but es- sentially can be reduced to problems whose input is an array presented as a stream of the array elements (or as a sequence of increments to the el- ements). For example, the array 𝑎 = [2, 1, 3] can be given as a stream {(𝑎[1] + 1), (𝑎[3] + 1), (𝑎[3] + 1), (𝑎[2] + 1), (𝑎[1] + 1), (𝑎[3] + 1)}. As- suming all the entries of the array take value 0 at the beginning of the stream, after the operations in the stream, we obtain the array 𝑎. There are many streaming algorithms that computes, for this array, statistics such as frequency moments [3, 24, 31], heavy hitters [13, 10], and construct succinct data structures that support queries such as range queries [38]. These algorithms can be directly applied once the graph problem is reduced to the corresponding problem of an array. We consider these problems involving the degree of the graph nodes. For an undirected graph, the degree of a node is the number of edges incident to the node. One may view that there is a virtual array 𝐷 associated with each graph such that 𝐷[𝑖] is the degree of the 𝑖-th node. In the streaming setting, a stream of edges translates to updates to the array 𝐷. For example, the stream {(1, 2), (4, 8), (2, 7) . . .} means the operation sequence: {(𝐷[1] + 1), (𝐷[2] + 1), (𝐷[4] + 1), (𝐷[8] + 1), (𝐷[2] + 1), (𝐷[7] + 1), . . .}. (The degree array can be extended to directed graph, where we may have one out-degree array and one in-degree array.) The frequency moment problem is to compute the k-th moment 𝑓 𝑘 = ∑ 𝑛 𝑖=1 (𝐷[𝑖]) 𝑘 of the node degrees. The heavy hitter problem is to report, after seeing the graph stream, the nodes having the largest degrees. The range query requires to construct a succinct representation of the array (one that is much smaller in size than the array), from which ∑ 𝑘 𝑖=𝑗 𝐷[𝑖], given j and k as query input, can be calculated. Cormode and Muthu show [14] that these problems can be solved using cor- responding streaming algorithms that work for an array. They further provide algorithms for these problems when the graph is a multigraph, but the degree of a node is defined to count only the distinct edges. (e.g. if the stream for a multigraph has edges (1, 2), (2, 5), (1, 2), the degree of the node 1 is 1, not 2 and the degree of the node 2 is 2, not 3.) The details of the algorithms are out of the scope of this survey. We refer readers to [14] and the aforementioned 398 MANAGING AND MINING GRAPH DATA literatures for streaming algorithms that compute statistics and other queries for an array. The node degree of a graph is also related to the entropy 𝐻 of an un- biased random walk on the graph [9]. In particular, 𝐻 is defined to be 𝐻 = 1 2∣𝐸∣ ∑ 𝑛 𝑖=1 𝐷[𝑖] log 𝐷[𝑖]. A streaming algorithm that computes the en- tropy for an array, of which the 𝑖-th entry represents the frequency of the 𝑖-th element in a set is given in [9]. The authors showed that the algorithm can be applied to compute the entropy when the array is the node-degree array 𝐷 for a graph, and therefore the entropy of an unbiased random walk can be calculated for a graph stream. They also extended the algorithm to multigraphs where only distinct edges are counted for the degree. Another problem that can be reduced to computing statistics of an array is the triangle counting problem, i.e., to find the number of triangles in an undirected graph. We describe here the reduction introduced by Bar-Yossef et. al [6]. Similar to the earlier problems, there is a virtual array 𝑃 associated with the graph. Each entry in the array corresponds to an (unordered) triple of the graph nodes. e.g., if 𝑣 𝑖 , 𝑣 𝑗 , 𝑣 𝑘 are three nodes in the graph, there is an entry 𝑃 [(𝑖, 𝑗, 𝑘)] in the array corresponds to the triple {𝑣 𝑖 , 𝑣 𝑗 , 𝑣 𝑘 }. The value of the entry counts how many of the three pairs {𝑣 𝑖 , 𝑣 𝑗 }, {𝑣 𝑖 , 𝑣 𝑘 }, and {𝑣 𝑗 , 𝑣 𝑘 } are actual edges in the graph. There are 4 possible values for the entries. 0, 1, 2, and 3. Let 𝑇 0 , 𝑇 1 , 𝑇 2 , and 𝑇 3 be the number of entries that take the corresponding value. Clearly, 𝑇 3 is exactly the number of triangles in the graph. (We will abuse the notation and also use 𝑇 𝑖 to denote the set of triples whose entry value is 𝑖.) Different from the reduction described earlier, an edge in the graph stream here maps into updates of multiple entries in the array. If we see an edge (𝑢, 𝑣), it means (𝑃 [(𝑢, 𝑣, 𝑠)] + 1) for all nodes 𝑠 ∕= 𝑢, 𝑣. Now consider the frequency moments of the array 𝑓 𝑘 = ∑ 𝑡 (𝑃 [𝑡]) 𝑘 . It can be decomposed into 𝑓 𝑘 = 𝑇 1 ⋅ 1 𝑘 + 𝑇 2 ⋅ 2 𝑘 + 𝑇 3 ⋅ 3 𝑘 because each entry with value 1 contributes 1 𝑘 to 𝑓 𝑘 , with value 2, 2 𝑘 and with value 3, 3 𝑘 . We can have the following equations: ⎛ ⎝ 𝑓 0 𝑓 1 𝑓 2 ⎞ ⎠ = ⎛ ⎝ 1 1 1 1 2 3 1 4 9 ⎞ ⎠ ⋅ ⎛ ⎝ 𝑇 1 𝑇 2 𝑇 3 ⎞ ⎠ . Using streaming algorithms one can estimate 𝑓 0 , 𝑓 2 . 𝑓 1 can be easily ob- tained from the stream. Solving the above equation then gives us the estimate of 𝑇 3 . (Although the size of the virtual array is larger than the size of the graph stream, e.g., a stream of 𝑚 edges corresponds to an array with 𝑚(𝑛 −2) entries, the estimate algorithms often use space logarithmic to the size of the array. Therefore, the memory space needed is not significantly affected by the reduction.) A Survey on Streaming Algorithms for Massive Graphs 399 In [6], Bar-Yossef et al.also proposed improved streaming frequency- moment estimate algorithms. Using the reduction and their frequency-moment estimation, they show that for 𝜖, 𝛿 > 0, the number of triangles in a graph can be estimated within 𝜖 error (i.e., the estimate is bounded between (1−𝜖)𝑇 3 and (1 + 𝜖)𝑇 3 ) with at least 1 − 𝛿 probability. The algorithm uses space 𝑠 = 𝑂 1 𝜖 3 ⋅ log 1 𝛿 ⋅ 𝑇 1 + 𝑇 2 + 𝑇 3 𝑇 3 3 ⋅ log 𝑛 and poly(𝑠) process time for each edge. When the stream is an incident stream, they show that, the number of triangles can be (𝜖, 𝛿)-estimated using space 𝑂 1 𝜖 2 ⋅ log 1 𝛿 ⋅ 𝑇 3 + 𝑇 2 𝑇 3 2 ⋅ log 𝑛 + 𝑑 𝑚𝑎𝑥 log 𝑛 . where 𝑑 𝑚𝑎𝑥 is the maximum degree. In a follow-up work, Jowhari and Ghodsi [33] introduced several estimators for the number of triangles. One estimator uses sequences of random numbers in a way similar to [3]. Let 𝑅 be an array of uniform, ±1-valued random numbers, i.e., 𝑃 (𝑅[𝑖] = 1) = 𝑃 (𝑅[𝑖] = −1) = 0.5 and 𝐸(𝑅[𝑖]) = 0. The random numbers in the array are 12-wise independent. A family of such random arrays can be constructed using the BCH code [3] in log-space. While the edges stream by, one computes 𝑍 = (𝑖,𝑗)∈𝐸 𝑅[𝑖]𝑅[𝑗]. 𝑋 = 𝑍 3 /6 is then an estimator for the number of triangles in the graph. This is so because 𝐸(𝑅 𝑘 [𝑖]) = 0 for odd 𝑘 and the numbers in 𝑅 are 12-wise independent. After the expansion of 𝑋, the expectations of the terms all evaluate to zero except those in form of 6𝑅 2 [𝑖]𝑅 2 [𝑗]𝑅 2 [𝑘], which correspond to the triangles. Jowhari and Ghodsi showed that the variance of the estimator can be controlled such that only 𝑂( 1 𝜖 2 ⋅log 1 𝛿 ⋅( 𝑚 3 +𝑚𝐶 4 +𝐶6 𝑇 2 3 +1)⋅log 𝑛) space and per-edge processing time is needed for an (𝜖, 𝛿)-estimation. (𝐶 𝑘 is the number of cycles of length 𝑘 in the graph.) Another two sample-based estimators are also proposed in [33]. Buriol et al.also proposed sample-based algorithms for counting triangles in [8]. We present one of their algorithms in Algorithm 13.1. 𝛽 is a {0, 1}-valued random variable whose expectation is 3𝑇 3 𝑇 1 +2𝑇 2 +3𝑇 3 . Be- cause 𝑇 1 + 2𝑇 2 + 3𝑇 3 = 𝑚(𝑛 − 2), (Consider the triples consist of two end nodes of an edge plus one node from the other 𝑛 −2. There are 𝑚(𝑛 −2) such combinations. On the other hand, this way of counting counts each triple in 𝑇 1 once, triples in 𝑇 2 twice and triples in 𝑇 3 three times. Hence the equality.) 𝑇 3 can be estimated using a set of samples of 𝛽. For making (𝜖, 𝛿)-estimation, this algorithm uses 𝑂(( 1 𝜖 2 ⋅log 1 𝛿 ⋅ 𝑇 1 +𝑇 2 +𝑇 3 𝑇 3 ) memory space and constant expected per-edge process time. Buriol et al.further showed that Algorithm 13.1 can be modified into a one- pass algorithm. The uniform sampling of the edges can be done in one pass by 400 MANAGING AND MINING GRAPH DATA Algorithm 13.1: Sample Triangle 1st pass: Count the number of edges in the graph.1 2nd pass: Sample an edge (𝑢, 𝑣) uniformly. Choose a node 𝑤 uniformly2 from 𝑉 ∖ {(𝑢, 𝑣)}. 3rd pass: 3 if Both (𝑢, 𝑤) and (𝑣, 𝑤) are actual edges in the stream then4 𝛽 = 15 else6 𝛽 = 07 end8 return 𝛽9 reservoir sampling [43]. One difference here is that edges (𝑢, 𝑤) and (𝑣, 𝑤) may arrive before (𝑢, 𝑣) in the stream. When (𝑢, 𝑣) gets selected as a sample, we have missed (𝑢, 𝑤) and (𝑣, 𝑤) and would not detect 𝑢, 𝑣, 𝑤 as an triangle. This happens when (𝑢, 𝑣) is not the first edge of the triangle in the stream and it reduces the expectation of 𝛽 by a factor of 3. Sample-based algorithms are also proposed in [8] for incidence streams. 4. Graph Matching A matching in a graph is a set of edges without common nodes. For an un- weighted graph, the maximum matching problem is to find a matching having the largest cardinality (number of edges). For a weighted graph, the problem is to find a matching whose edges give the largest weight sum. We survey un- weighted and weighted matching algorithms for graph streams in the following sections. 4.1 Unweighted Matching An early algorithm for approximating unweighted bipartite matching in the streaming model is given in [22]. We describe the algorithm here. It is easy to see that a maximal matching (A matching no more edge can be added because every edge outside the match share a vertex with some edge in the matching.) can be constructed in one pass over the graph stream. Given a matching 𝑀 for a bipartite graph 𝐺 = (𝐿 ∪ 𝑅, 𝐸), a length-3 aug- menting path for an edge 𝑒 = (𝑢, 𝑣) ∈ 𝑀, 𝑢 ∈ 𝐿 and 𝑣 ∈ 𝑅, is a quadruple (𝑤 𝑙 , 𝑢, 𝑣, 𝑤 𝑟 ) such that (𝑢, 𝑤 𝑙 ), (𝑤 𝑟 , 𝑣) ∈ 𝐸, and 𝑤 𝑙 and 𝑤 𝑟 are free vertices. We call 𝑤 𝑙 and 𝑤 𝑟 the wing-tips of the augmenting path, (𝑢, 𝑤 𝑙 ) the left wing and (𝑤 𝑟 , 𝑣) the right wing. A set of simultaneously augmentable length-3 aug- menting paths is a set of length-3 augmenting paths that are vertex disjoint. A Survey on Streaming Algorithms for Massive Graphs 401 Algorithm 13.2: Find Augmenting Paths Input: a graph 𝐺 = (𝐿 ∪ 𝑅, 𝐸), a matching 𝑀 for 𝐺 and a parameter 0 < 𝛿 < 1. while true do 1 In one pass, find a maximal set of disjoint left wings. If the number of2 left wings found is ≤ 𝛿𝑀, terminate. In a second pass, for the edges in 𝑀 with left wings, find a maximal 3 set of disjoint right wings. In a third pass we identify the set of vertices that are 4 endpoints of a matched edge that got a left wing, or the wing tips of a matched edge that got both wings, or endpoints of a matched edge that is no longer 3 augmentable. We remember these vertices and in subsequent passes, we ignore any edge incident on one of these vertices. end 5 Given a bipartite graph and a matching in the graph, the subroutine in Al- gorithm 13.2 finds a set of simultaneously augmentable length-3 augmenting paths. It will be used in the main algorithm that computes the matching for a bipartite graph. Let 𝑋 be a maximum-sized set of simultaneously augmentable length-3 augmenting paths for the maximal matching 𝑀. Let 𝛼 = ∣𝑋∣ ∣𝑀∣ . It is shown in [22] that Algorithm 13.2 finds at least 𝛼∣𝑀∣−2𝛿∣𝑀∣ 3 simultaneously aug- mentable length-3 augmenting paths in 3/𝛿 passes. The main matching algorithm increases the size of a matching by repeatedly finding a set of simultaneously augmentable length-3 augmenting paths and augmenting the matching using these paths. The for-loop in Algorithm 13.3 runs ⌈ log 6𝜖 𝑙𝑜𝑔8/9 ⌉ times. During each run, the subroutine described in Algorithm 13.2 needs to go through the input graph stream 3/𝛿 passes. Therefore, Algorithm 13.3 in total goes through the stream 𝑂 ( log 1/𝜖 𝜖 ) passes. Each call to the subroutine will find a set of simultane- ously augmentable length-3 augmenting paths which increases the size of the matching. The final matching size reaches at least (2/3 − 𝜖) of the maximum matching. The algorithm processes each edge in 𝑂(1) time in each pass except the first pass, in which the bipartition is found. The storage space required by the algorithm is 𝑂(𝑛 log 𝑛). 402 MANAGING AND MINING GRAPH DATA Algorithm 13.3: Unweighted Bipartite Matching Input: a bipartite graph 𝐺 = (𝐿 ∪ 𝑅, 𝐸) and a parameter 0 < 𝜖 < 1/3. In one pass, find a maximal matching 𝑀 and the bipartition of 𝐺. 1 for 𝑘 = 1, 2, . . . , ⌈ log 6𝜖 𝑙𝑜𝑔8/9 ⌉ do 2 Run Algorithm 13.2 with 𝐺, 𝑀 and 𝛿 = 𝜖 2−3𝜖 . 3 for each 𝑒 = (𝑢, 𝑣) ∈ 𝑀 for which an augmenting path (𝑤 𝑙 , 𝑢, 𝑣, 𝑤 𝑟 )4 is found by algorithm 13.2 do remove (𝑢, 𝑣) from 𝑀 and add (𝑢, 𝑤 𝑙 ) and (𝑤 𝑟 , 𝑣) to 𝑀.5 end6 end7 Figure 13.1. Layered Auxiliary Graph. Left, a graph with a matching (solid edges); Right, a layered auxiliary graph. (An illustration, not constructed from the graph on the left. The solid edges show potential augmenting paths.) In [35], McGregor introduced an improved algorithm to find augmenting paths in an unweighted graph for which a maximal match has been constructed. Given the original input graph 𝐺 and a matching 𝑀, McGregor constructed an auxiliary graph 𝐺 𝐴 to help searching for augment paths. Fig 13.1 gives an example of one auxiliary graph. The auxiliary graph is a layered graph with a small number, 𝑘+2, of layers. It is derived as follows: Let 𝐿 0 , 𝐿 1 , . . . , 𝐿 𝑘+1 be the layers in 𝐺 𝐴 . The free nodes in 𝐺, i.e. the nodes that haven’t been covered by an edge in 𝑀, are randomly projected to be nodes in 𝐿 0 or 𝐿 𝑘+1 . The edges in 𝑀 are projected to be a node in 𝐺 𝐴 and this node is randomly assigned to be in a layer of 𝐿 1 , 𝐿 2 , . . . , 𝐿 𝑘 . There is an edge between a node 𝑥 ∈ 𝐿 𝑖 (that corresponding to (𝑣 1 , 𝑣 2 ) ∈ 𝑀) and a node 𝑦 ∈ 𝐿 𝑖−1 (that corresponding to (𝑣 3 , 𝑣 4 ) ∈ 𝑀) if (𝑣2, 𝑣3) ∈ 𝐺. With this construction, an (𝑖 + 1)-length path in 𝐺 𝐴 can be mapped to a (2𝑖 + 1)-length augmenting path for 𝑀 in 𝐺. Identifying a set of augmenting paths for 𝑀 in 𝐺 now is transformed to find a set of node-disjoint paths in 𝐺 𝐴 . Because one doesn’t have enough space to store the whole graph 𝐺 in the streaming model, normally, the auxiliary graph 𝐺 𝐴 cannot be stored as a whole graph neither. However, the nodes in A Survey on Streaming Algorithms for Massive Graphs 403 𝐺 𝐴 can be stored. While the algorithm passes through the input stream of 𝐺, the edges in 𝐺 𝐴 also gets revealed. Hence, the problem boils down to find a near-maximal set of node-disjoint paths in 𝐺 𝐴 . A search algorithm was proposed in [35] for this purpose. The algorithm finds a maximal matching between layers 𝐿 𝑖−1 and 𝐿 𝑖 . Let 𝑆 𝑖 ∈ 𝐿 𝑖 be the set of nodes involved in this matching. The algorithm then goes ahead to find a maximal matching between 𝑆 𝑖 and 𝐿 𝑖+1 . It continues in this fashion to grow a set of node-disjoint paths. Clearly, the size of 𝑆 𝑖 may decrease while 𝑖 increases and may become empty before the last layer is reached. To avoid this, the path growth process may backtrack if the size of 𝑆 𝑖 becomes too small. The backtrack is done by marking the nodes in 𝑆 𝑖 as deadends, removing them from 𝐺 𝐴 and continuing path growth in the remaining of 𝐺 𝐴 . For a particular 𝐺 𝐴 construction and path growth, the resulting set of paths may be small. However, the 𝐺 𝐴 construction is random because the nodes cor- responding to the edges in 𝑀 are randomly assigned to the layers. A matching algorithm is given in [35] that is similar to Algorithm 13.3 in structure but uti- lizes the 𝐺 𝐴 -based augmenting-path search. It is shown that, with high proba- bility, this algorithm finds a matching in 𝑂 𝜖 (1) (a function of 𝜖 and a constant is 𝜖 is constant) passes whose size is at least 1 1+𝜖 of the maximum matching. 4.2 Weighted Matching The streaming version of the problem was first studied in [22] where a streaming algorithm (Algorithm 13.4) was proposed. The algorithm uses only one pass over the stream and manages to find a matching which is at least 1 6 of the optimal size. Algorithm 13.4: Weighted Matching Maintain a matching 𝑀 at all times.1 while there are edges in the stream do2 Let 𝑒 be the next edge in the stream and 𝑤(𝑒) be the weight of 𝑒;3 Let 𝑤(𝐶) be the sum of the weights of the edges in4 𝐶 = {𝑒 ′ ∣𝑒 ′ ∈ 𝑀 and 𝑒 ′ and 𝑒 share an end point}. (𝑤(𝐶) = 0 if 𝐶 is empty.) if 𝑤(𝑒) > 2𝑤(𝐶) then 5 update 𝑀 ← 𝑀 ∪ {𝑒} ∖ 𝐶.6 else7 ignore 𝑒8 end9 end10 The following property of Algorithm 13.4 is shown in [22]. 404 MANAGING AND MINING GRAPH DATA Theorem 13.2. In 1 pass and 𝑂(𝑛 log 𝑛) storage, Algorithm 13.4 constructs a weighted matching that is at least 1 6 of the optimal size. Proof: For any set of edges 𝑆, let 𝑤(𝑆) = 𝑒∈𝑆 𝑤(𝑒). We say that an edge is selected if it is ever part of 𝑀 . We say that an edge is dropped if it was selected early but later replaced from 𝑀 (step 6 in Algorithm 13.4) by a new heavier edge. This new edge replaces the dropped edge. We say an edge is a survivor if it is selected and never dropped. Let the set of survivors be 𝑆. The weight of the matching we find is therefore 𝑤(𝑆). For each survivor 𝑒, let the Trail of Drops leading to this edge be 𝑇 (𝑒) = 𝐶 1 ∪ 𝐶 2 ∪ . . . where 𝐶 0 = {𝑒}, 𝐶 1 = {the edges replaced by 𝑒}, and 𝐶 𝑖 = ∪ 𝑒 ′ ∈𝐶 𝑖−1 {the edges replaced by 𝑒 ′ }. We have 𝑤(𝑇 (𝑒)) ≤ 𝑤(𝑒). This is because for each replacing edge 𝑒, 𝑤(𝑒) is at least twice the cost of the re- placed edges, and an edge has at most one replacing edge. Hence, for all 𝑖, 𝑤(𝐶 𝑖 ) ≥ 2𝑤(𝐶 𝑖+1 ) and 2𝑤(𝑇 (𝑒)) = 𝑖≥1 2𝑤(𝐶 𝑖 ) ≤ 𝑖≥0 𝑤(𝐶 𝑖 ) = 𝑤(𝑇 (𝑒)) + 𝑤(𝑒). Now consider the optimal solution that includes edges opt = {𝑜 1 , 𝑜 2 , . . .}. We are going to charge the costs of the edges in opt to the survivors and their trail of drops, ∪ 𝑒∈𝑆 𝑇 (𝑒) ∪ {𝑒}. We hold an edge 𝑒 in this set accountable to 𝑜 ∈ opt if either 𝑒 = 𝑜 or if 𝑜 wasn’t selected because 𝑒 was in 𝑀 when 𝑜 arrived. Note that, in the second case, it is possible for two edges to be accountable to 𝑜. If only one edge is accountable for 𝑜 then we charge 𝑤(𝑜) to 𝑒. If two edges 𝑒 1 and 𝑒 2 are accountable for 𝑜, then we charge 𝑤(𝑜)𝑤(𝑒 1 ) 𝑤(𝑒 1 )+𝑤 (𝑒 2 ) to 𝑒 1 and 𝑤(𝑜)𝑤(𝑒 2 ) 𝑤(𝑒 1 )+𝑤 (𝑒 2 ) to 𝑒 2 . In either case, the amount charged by 𝑜 to any edge 𝑒 is at most 2𝑤(𝑒). We now redistribute these charges as follows: (for distinct 𝑢 1 , 𝑢 2 , 𝑢 3 ) if 𝑒 = (𝑢 1 , 𝑣) gets charged by 𝑜 = (𝑢 2 , 𝑣), and 𝑒 subsequently gets replaced by 𝑒 ′ = (𝑢 3 , 𝑣), we transfer the charge from 𝑒 to 𝑒 ′ . Note that we maintain the property that the amount charged by 𝑜 to any edge 𝑒 is at most 2𝑤(𝑒) because 𝑤(𝑒 ′ ) ≥ 𝑤(𝑒). What this redistribution of charges achieves is that now every edge in a trail of drops is only charged by one edge in opt. Survivors can, however, be charged by two edges in opt. We charge 𝑤(opt) to the survivors and their trails of drops, and hence 𝑤(opt) ≤ 𝑒∈𝑆 (2𝑤(𝑇 (𝑒)) + 4𝑤(𝑒)) . Because 𝑤(𝑇 (𝑒)) ≤ 𝑤(𝑒), 𝑒∈𝑆 (2𝑤(𝑇 (𝑒)) + 4𝑤(𝑒)) ≤ 6𝑤(𝑆) A Survey on Streaming Algorithms for Massive Graphs 405 and the theorem follows. □ The condition on line 5 of Algorithm 13.4 can be generalized to be 𝑤(𝑒) > (1 + 𝛾)𝑤(𝐶), 𝐶 = {𝑒 ′ ∣𝑒 ′ ∈ 𝑀 and 𝑒 ′ and 𝑒 share an end point}. By setting 𝛾 appropriately and repeating Algorithm 13.4 until the improvement yielded falls below some threshold, a matching can be constructed [35] in 𝑂 𝜖 (1) passes whose size is at least 1 2+𝜖 of the maximum matching. Another improvement for weighted matching was made recently by Zelke [46]. Zelke’s algorithm is also based on Algorithm 13.4, but incorpo- rates some improvements. In particular, the algorithm stores a few edges that have been in 𝑀 in the past but were replaced later, to potentially reinsert them into 𝑀 in the future. Such edges are called in [46] the “shadow edges." With shadow edges, when a new edge arrives in the stream, besides the (two) edges that sharing the endpoints with the new edge, a few other edges (edges in 𝑀 as well as the shadow edges) in the vincinity of the new edge can be examined to find potential augmenting path. This improves the approximation from 1/5.82 (by an algorithm in [35]) to 1/5.58. 5. Graph Distance We consider the shortest-path distance in a graph. The shortest path between two vertices in a graph is the path that has the smallest number of edges (for an unweighted graph) or the smallest sum of the weights of the path edges (for a weighted graph). There may be more than one such shortest path. A structure often used in approximating graph distance is the graph span- ner [39, 11, 18]. An undirected graph 𝐺 = (𝑉, 𝐸) induces a metric space 𝒰 in which the vertex set 𝑉 serves as the set of points, and the shortest- path distances serve as the distances between the points. The graph spanner 𝐺 ′ = (𝑉, 𝐻), 𝐻 ⊆ 𝐸, is a sparse skeleton of the graph 𝐺 whose induced metric space 𝒰 ′ is a close approximation of the metric space 𝒰 of the graph 𝐺. That is, the distance between two vertices in 𝐺 ′ is not far from the distance between the same two vertices in 𝐺. For example, a subgraph 𝐺 ′ = (𝑉, 𝐻), 𝐻 ⊆ 𝐸 is a (multiplicative) 𝑡-spanner of the graph 𝐺, if for every pair of ver- tices 𝑢, 𝑣 ∈ 𝑉 , 𝑑𝑖𝑠𝑡 𝐺 ′ (𝑢, 𝑣) ≤ 𝑡 ⋅ 𝑑𝑖𝑠𝑡 𝐺 (𝑢, 𝑣) (where 𝑑𝑖𝑠𝑡 𝐺 (𝑢, 𝑣) stands for the distance between the vertices 𝑢 and 𝑣 in the graph 𝐺). The stretch factor of a spanner is the parameter(s) that determines how close the spanner approx- imates the distances in the original graph, e.g., in the case of a 𝑡-spanner, the parameter 𝑡. Clearly, if a spanner can be constructed for a massive graph, one can approx- imate the node distance in the graph using the spanner. Because the spanner is much smaller than the original graph, it can often be stored in the main memory. In fact, an early application of spanners is to maintain a succinct rep- resentation of the routing information [39, 11]. Instead of the original network 406 MANAGING AND MINING GRAPH DATA graph, spanners are passed and stored by the routers for calculating the routing paths. Besides distances, the diameter of a graph can be approximated using the spanner diameter. In [22], Feigenbaum et al.gave a simple streaming algorithm for spanner- construction by adapting the technique of [4]. It displays a certain connection between the girth of a graph and the spanner. (The girth of a graph is the length of the shortest cycle in the graph.) However, in the worst case, the algorithm needs more than 𝑂(𝑛) time to process an edge. Such a processing time is prohibitively high for the streaming model. For an unweighted graph, the algorithm of [22] in one pass constructs a (log 𝑛/ log log 𝑛)-spanner 𝑆: Because a graph whose girth is larger than 𝑘 have at most ⌈𝑛 1+2/(𝑘−2) ⌉ edges [7, 17, 2], the algorithm constructs 𝑆 by adding an edge in the stream to 𝑆 if the edge does not cause a cycle of length less than log 𝑛/ log log 𝑛 in the 𝑆 constructed so far. Otherwise, the edge is ignored. Note that for each ignored edge, there is a path 𝑃 of length at most log 𝑛/ log log 𝑛 in 𝑆 that connects the two endpoints of this edge. Any shortest path in the original graph that uses this edge can be replaced by a path in 𝑆 that uses 𝑃 . Therefore, 𝑆 is a log 𝑛/ log log 𝑛 spanner of the original graph. For a weighted graph, however, the construction in [4] requires sorting the edges according to their weights, which is difficult in the streaming model. Instead of sorting, a geometric grouping technique is used in [22] to extend the spanner construction for unweighted graphs to a construction for weighted graphs. This technique is similar to the one used in [12]. Let 𝜔 𝑚𝑖𝑛 be the minimum weight and 𝜔 𝑚𝑎𝑥 be the maximum weight. We divide the range [𝜔 𝑚𝑖𝑛 , 𝜔 𝑚𝑎𝑥 ] into intervals of the form [(1 + 𝜖) 𝑖 𝜔 𝑚𝑖𝑛 , (1 + 𝜖) 𝑖+1 𝜔 𝑚𝑖𝑛 ) and round all the weights in the interval [(1+𝜖) 𝑖 𝜔 𝑚𝑖𝑛 , (1+𝜖) 𝑖+1 𝜔 𝑚𝑖𝑛 ) down to (1+ 𝜖) 𝑖 𝜔 𝑚𝑖𝑛 . For each induced graph 𝐺 𝑖 = (𝑉, 𝐸 𝑖 ), where 𝐸 𝑖 is the set of edges in 𝐸 whose weight is in the interval [(1+𝜖) 𝑖 𝜔 𝑚𝑖𝑛 , (1+𝜖) 𝑖+1 𝜔 𝑚𝑖𝑛 ), a spanner can be constructed in parallel using the above construction for unweighted graphs. The union of the spanners for all the 𝐺 𝑖 , 𝑖 ∈ {0, 1, . . . , log (1+𝜖) 𝜔 𝑚𝑎𝑥 𝜔 𝑚𝑖𝑛 − 1}, forms a spanner for the graph 𝐺. Note that this can be done without prior knowledge of 𝜔 𝑚𝑖𝑛 and 𝜔 𝑚𝑎𝑥 . The goal is to break the range [𝜔 𝑚𝑖𝑛 , 𝜔 𝑚𝑎𝑥 ] into a small number of intervals. Given any value 𝜔 ∈ [𝜔 𝑚𝑖𝑛 , 𝜔 𝑚𝑎𝑥 ], we can use the set of intervals of the form [(1 + 𝜖) 𝑖 𝜔, (1 + 𝜖) 𝑖+1 𝜔) and [ 𝜔 (1+𝜖) 𝑖+1 , 𝜔 (1+𝜖) 𝑖 ). Therefore, we can determine the intervals without the prior knowledge of 𝜔 𝑚𝑖𝑛 and 𝜔 𝑚𝑎𝑥 . 5.1 Distance Approximation using Multiple Passes Elkin and Zhang gave a multiple-pass streaming spanner construction in [21]. This algorithm builds an additive spanner. A subgraph 𝐺 ′ = (𝑉, 𝐻)