The swap edges of a multiple-sources routing tree

The swap edges of a multiple-sources routing tree

Bang Ye Wu^∗ Chih-Yuan Hsiao^† Kun-Mao Chao^‡

Abstract

Let T be a spanning tree of a graph G and S ⊂ V (G) be a set of sources. The routing cost of T is the total distance from all sources to all vertices. For an edge e of T , the swap edge of e is the edge f minimizing the routing cost of the tree formed by replacing e with f . Given an undirected graph G and a spanning tree T of G, we investigate the problem of finding the swap edge for every tree edge. In this paper, we propose an O(m log n + n²)-time algorithm for the case of two sources and an O(mn)-time algorithm for the case of more than two sources, where m and n are the numbers of edges and vertices of G, respectively.

Key words: algorithm, graph, swap edge, spanning tree, optimization problem.

1 Introduction

A routing tree of a graph is a spanning tree, along which the messages can be routed from sources to destinations. Let G = (V, E, w) be an undirected graph with nonnegative edge length function w. All vertices are destinations, whereas some of them are sources.

The routing cost of a spanning tree is defined by the total distance from sources to all vertices. For the sake of efficiency, the routing cost should be made as small as

∗bangye@mail.stu.edu.tw, Department of Computer Science and Information Engineering, Shu-Te University, YenChau, Kaohsiung, Taiwan 824, R.O.C.

†skiky@mail2000.com.tw, Department of Computer Science and Information Engineering, National Taiwan University, Taipei, Taiwan 106, R.O.C.

‡corresponding author, kmchao@csie.ntu.edu.tw, Department of Computer Science and Information Engineering / Graduate Institute of Networking and Multimedia, National Taiwan University, Taipei, Taiwan 106, R.O.C.

possible. Given a graph and a set of p sources, the problem of finding the minimum routing cost spanning tree (MRCT) is NP-hard for any constant p > 1 [9]. When p = 1, i.e., there is only one source, it is reduced to the well-known single-source shortest- paths tree problem and can be solved in polynomial time. For the p-sources MRCT problem, several approximation algorithms have been reported, including a polynomial time approximation scheme (PTAS) for the case that all vertices are sources [12], a PTAS for the case of two sources [8], and a 2-approximation algorithm for an arbitrary number of sources [11]. A survey of the MRCT and some other related problems can be found in [10].

The survivability of a network is the ability to recover the communication if a link of the network fails [3]. A tree has the benefits of low cost and simple routing algorithms, but it suffers from weak survivability. Therefore, how to recover a tree from failures is an important issue. Any edge of a spanning tree corresponds to a bipartition of the vertex set. To recover a spanning tree from the failure of an edge, we need to find another edge crossing the bipartition so as to minimize the routing cost. For an edge e of T , the swap edge of e is the edge f minimizing the routing cost of the tree formed by replacing e with f .

Let m and n be the numbers of edges and vertices of the input graph, respectively.

In [7], the authors proposed an O(n²)-time algorithm for finding the swap edge for every edge of a single-source shortest-paths tree. More recently, an O(m log²n)-time algorithm for the same problem was reported in [1], which improves the previous one for sufficiently sparse graphs. In this paper, we investigate the problem of finding the swap edge for every tree edge when the number of sources is more than one. We present an O(m log n + n²)- time algorithm for the case of two sources and an O(mn)-time algorithm for the case of more than two sources.

The rest of the paper is organized as follows. We first formally define the notations and the problem in Section 2. In Section 3, we propose an O(m log n+n²)-time algorithm for the two-sources case. Then we propose an O(mn)-time algorithm for the multiple- sources case in Section 4. Finally, concluding remarks are given in Section 5.

2 Preliminaries

By G = (V, E, w), we denote a graph G with vertex set V , edge set E, and edge weight (length) function w. In this paper, we consider only undirected graphs with nonnegative edge lengths. For any graph G, the vertex set and edge set are denoted by V (G) and E(G) respectively. Let T be a spanning tree of G. For any e ∈ E(T ), the removal of e cuts T into two subtrees, of which the vertex sets form a bipartition (V₁, V₂) of V (G).

By C(e), we denote the cut set of the bipartition, i.e., the set of edges with one endpoint in V₁ and the other endpoint in V₂. For convenience, we assume that e /∈ C(e). It is clear that if C(e) 6= ∅, then the two subtrees can be connected to form another spanning tree of G by inserting any edge in the cut set. We use T_e/f to denote the new spanning tree obtained by replacing an edge e with another edge f ∈ C(e).

For u, v ∈ V (G), the distance between u and v in G is denoted by d_G(u, v), which is the total length of the edges in a shortest path between the two vertices. For U ⊂ V (G), let D_G(v, U ) =^P_u∈U d_G(v, u) denote the total distance from v to all vertices in U . For a subgraph H, we also use D_G(v, H) to denote D_G(v, V (H)). A source (vertex) is a distinguished vertex in V (G). For a given set S of source vertices, the routing cost of a spanning tree T is denoted by c(T, S), which is the total distance from sources to all vertices, i.e., c(T, S) =^P_s∈SD_T(s, T ). When there is no confusion, we also simply use c(T ) for the routing cost. For an edge e ∈ E(T ), the swap cost is defined by χ(T, e) = min_{f ∈C(e)}c(T_e/f, S), which is the minimum routing cost of any spanning tree obtained by replacing e with another edge. The swap edge problem is formally defined

as follows:

Problem: Swap Edges for a Routing Tree (SERT)

Instance: A graph G = (V, E, w), a spanning tree T of G, and a set S ⊂ V of sources.

Goal: For each e ∈ E(T ), find χ(T, e).

In case that C(e) is empty for some e, we say that there is no swap edge for e and the cost χ(T, e) = ∞. Since the swap edges will be implicitly determined when minimizing the swap costs, we shall focus on the swap costs only. In the remaining paragraphs, we shall assume that G, T , and S are the input data of the SERT problem.

3 Two-sources case

In this section, we discuss the two-sources case of the SERT problem. Let S = {s₁, s₂} ⊂ V be the set of two specified source vertices and P = (s₁ = r₀, r₁, r₂, . . . , r_k= s₂) be the path between the two sources in T . The routing cost of T in this case is defined by

c(T, S) = ^X

v∈V

D_T(v, S) = ^X

v∈V

(d_T(v, s₁) + d_T(s₂, v)) .

Removing all the edges of P from T divides T into k + 1 subtrees. Let T_i denote the subtree containing r_i and V_i= V (T_i) for 0 ≤ i ≤ k. Our method for computing the swap costs for all tree edges is divided into two parts: e /∈ E(P ) and e ∈ E(P ).

3.1 Edges not in the path

To compute the swap costs of edges in T_i, we treat all vertices not in V_i as a super node, and reduce the problem to the single-source case, as shown in Figure 1. Construct an auxiliary graph G_i= (V_i⁰, E_i⁰, w⁰_i) by shrinking all vertices not in V_i to a created vertex s as follows.

• V_i⁰ = V_i∪ {s}, in which s /∈ V is a created node.







 





























Figure 1: The super node s for reduction to single-source SERT problem.

• The edge set E_i⁰ consists of two parts: The first part contains all the edges of which both endpoints are in V_i, and the other part contains the edges (s, v) if there exists an edge (v, u) crossing the cut (V_i, V − V_i) for any v ∈ V_i.

• For each edge (u, v) such that u, v ∈ V_i, set w⁰_i(u, v) = 2w(u, v).

• w_i⁰(s, r_i) = D_T(r_i, S) and for each edge (v, s), v ∈ V_i − {r_i}, set w_i⁰(v, s) = min_{u /∈Vi}{2w(u, v) + D_T(u, S)}.

Let T⁰ be the spanning tree of G_i, which is obtained by inserting edge (s, r_i) into T_i, and let s be the source of T⁰.

Lemma 1: For any vertex v ∈ V_i, D_T(v, S) = d_T⁰(v, s).

Proof:

d_T⁰(v, s) = d_T⁰(v, r_i) + w⁰_i(r_i, s)

= 2d_T(v, r_i) + D_T(r_i, S) = d_T(v, s₁) + d_T(v, s₂)

Similarly, the following result can be easily shown by the definitions, and the proof is omitted.

Lemma 2: The swap costs of all edges in T_ican be computed by solving the single-source SERT problem with input (G_i, T⁰, s).

Lemma 3: The swap costs for all edges not in P can be found in O(n²) time.

Proof: To compute the swap costs, for each V_i, we construct the auxiliary graph and then solve the single-source SERT problem. First we compute d_T(v, S) for every v ∈ V by traversing T twice: one for computing d_T(v, s₁) and the other for d_T(v, s₂). Also the set V_i for each i can be found by traversing the tree in linear time. To construct G_i, we traverse T_i in a depth first search order. By storing the graph in an adjacent list, all the auxiliary graphs can be constructed in O(n + m) time since each edge is checked twice.

Since the single-source SERT problem for G_i can be solved in O(|V (G_i)|²) time [7], the total time complexity is O(n²).

3.2 Edges in the path

In the following, we focus on how to find out the swap costs for the edges in P = (s₁ = r₀, r₁, r₂, . . . , r_k= s₂). Let e_i = (r_i, r_i+1) and n_i = |V_i|. Let Y_iand ¯Y_ibe the two subtrees obtained by removing the edge e_i from T , in which s₁ ∈ V (Y_i). Also let N_i = |V (Y_i)|.

Note that V (Y_i) =^S_j≤iV_j and N_i =^P_j≤in_j. For any f ∈ C(e_i) and H = T_e/f, we have

c(H) = (D_H(s₁, Y_i) + D_H(s₂, ¯Y_i)) + (D_H(s₂, Y_i) + D_H(s₁, ¯Y_i)).

Obviously, D_H(s₁, Y_i) = D_T(s₁, Y_i) and D_H(s₂, ¯Y_i) = D_T(s₂, ¯Y_i) since they are not affected by the removal of e_i. Let f = (x, y), as illustrated in Figure 2. By defini-



















































Figure 2: A swap edge for an edge (r_i, r_i+1) in the path between the two sources.

tion, D_H(s₂, Y_i) = D_T(x, Y_i) + N_i(w(f ) + d_T(y, s₂)) and D_H(s₁, ¯Y_i) = D_T(y, ¯Y_i) + (n − N_i)(w(f ) + d_T(x, s₁)). Let

δ(f, i) = D_H(s₂, Y_i) + D_H(s₁, ¯Y_i)

= D_T(x, Y_i) + D_T(y, ¯Y_i) + nw(f ) + N_id_T(y, s₂) + (n − N_i)d_T(x, s₁), (1)

and our goal is to compute

χ(T, e_i) = (D_T(s₁, Y_i) + D_T(s₂, ¯Y_i)) + min

f ∈C(ei)δ(f, i),

for every 0 ≤ i < k. By a na¨ıve method, δ(f, i) can be computed in O(n) time, which implies that the swap cost χ(T, e_i) can be computed in O(mn) time. Since the number of edges in P may be up to Ω(n), it takes totally O(mn²) to compute all the swap costs.

In the following, we present an incremental method and show that the two-sources SERT problem can be solved in O(m log n + n²) time.

Suppose that x ∈ V_p and y ∈ V_q, p < q. Observe that, for p < i < q,

δ(f, i) − δ(f, i − 1)

= ^¡D_T(x, Y_i) + D_T(y, ¯Y_i) + nw(f ) + N_id_T(y, s₂) + (n − N_i)d_T(x, s₁)^¢

−^¡D_T(x, Y_i−1) + D_T(y, ¯Y_i−1) + nw(f ) + N_i−1d_T(y, s₂) + (n − N_i−1)d_T(x, s₁)^¢

= (D_T(x, Y_i) − D_T(x, Y_i−1)) + (D_T(y, ¯Y_i) − D_T(y, ¯Y_i−1)) +(N_i− N_i−1)d_T(y, s₂) + ((n − N_i) − (n − N_i−1))d_T(x, s₁)

= D_T(x, V_i) − D_T(y, V_i) + n_id_T(y, s₂) − n_id_T(x, s₁).

Since D_T(x, V_i) − D_T(y, V_i) = n_i(d_T(r_i, x) − d_T(r_i, y)), we have

δ(f, i) − δ(f, i − 1)

= n_i(d_T(r_i, x) − d_T(r_i, y) + d_T(y, s₂) − d_T(x, s₁))

= n_i(d_T(r_i, x) − d_T(x, s₁) + d_T(y, s₂) − d_T(r_i, y))

= n_i(d_T(r_i, r_p) − d_T(r_p, s₁) + d_T(r_q, s₂) − d_T(r_i, r_q)) . (2)

It implies that δ(f, i) can be computed from δ(f, i−1) in constant time if all the required distances are available after a preprocessing stage. Consequently all the swap edges can be found in O(mn) time by computing δ(f, i) for each f and each i. In the following, we propose an efficient method to find the edge minimizing δ(f, i) without calculating δ(f, i) for all the edges crossing the cut.

For any edge (x, y) in which x ∈ V_p and y ∈ V_q, we say that x is the left endpoint and y is the right endpoint if p < q. In the following, we shall assume that x is in V_p, p < k. Let E_x denote the set of all edges with left endpoint x. Letf (i) = δ(f, i). Our^b approach is to compute a function F_x defined by

F_x(i) = min

f ∈Ex

f (i).b

Once the function F_x for each vertex x is determined, the minimized δ(f, i) can be found by taking the minimum of F_x(i) for all x. Since F_xis defined by the minimum of a set of functions, it can be regarded as a piecewise function. To determine F_x, it is required to find the consecutive intervals and to determine which of the functionsf is the minimum^b for each interval.

For two discrete functionsf^b₁ andf^b₂, we say the two functions intersect in the interval [l₁, l₂] if f^b₁(l₁) < f^b₂(l₁) and f^b₁(l₂) > f^b₂(l₂), or vice versa. If f^b₁(l₁) < f^b₂(l₁) and [l₁, l₂] is an intersection interval, the insertion point is the minimum i such thatf^b₁(i) >f^b₂(i).

Define right(f ) = q if the right endpoint of f is in V_q. We shall show some properties which are crucial for our algorithm.

Lemma 4: For two edges f₁ and f₂in E_x, if right(f₁) = right(f₂), thenf^b₁ andf^b₂never intersect. Furthermore, by an O(n²)-time preprocessing, we can determine which of the two functions is the smaller in constant time.

Proof: Let f₁ = (x, y₁), f₂ = (x, y₂), and right(f₁) = q. By (2), f^b₁(i) −f^b₁(i − 1) = fb₂(i) −f^b₂(i − 1) for any p < i < q. That is, the difference betweenf^b₁ and f^b₂ is fixed in the domain, thus they never intersect.

By (1),

fb₁(i) −f^b₂(i) = N_i(d_T(y₁, s₂) − d_T(y₂, s₂)) + n(w(x, y₁) − w(x, y₂))

+D_T(y₁, ¯Y_i) − D_T(y₂, ¯Y_i),

and

D_T(y₁, ¯Y_i) − D_T(y₂, ¯Y_i)

= (n − N_i− n_q)(d_T(r_q, y₁) − d_T(r_q, y₂)) + D_T(y₁, V_q) − D_T(y₂, V_q).

In a preprocessing stage, we compute the following:

• d_T(u, v) for any u, v ∈ V .

• For each vertex v, find i such that v ∈ V_i.

• n_i= |V_i| and N_i= |V (Y_i)| for each i.

• D_T(v, V_i) for each i and each v ∈ V_i.

The preprocessing can be done in O(n²) time. After the preprocessing stage, we can computef^b₁(i) −f^b₂(i) in constant time and determine the smaller one.

Lemma 5: If f₁, f₂ ∈ E_x and right(f₂) < right(f₁), the difference (f^b₂(i) −f^b₁(i)) is monotonically increasing as i increases for any p ≤ i < right(f₂).

Proof: Let right(f₂) = q and right(f₁) = j. For any p < i < q,

(f^b₂(i) −f^b₁(i)) − (f^b₂(i − 1) −f^b₁(i − 1))

= (f^b₂(i) −f^b₂(i − 1)) − (f^b₁(i) −f^b₁(i − 1))

= n_i(d_T(r_i, r_p) − d_T(r_p, s₁) + d_T(r_q, s₂) − d_T(r_i, r_q))

−n_i(d_T(r_i, r_p) − d_T(r_p, s₁) + d_T(r_j, s₂) − d_T(r_i, r_j))

= n_i((d_T(r_q, s₂) − d_T(r_j, s₂)) + (d_T(r_i, r_j) − d_T(r_i, r_q)))

= n_i(d_T(r_q, r_j) + d_T(r_q, r_j))

= 2n_id_T(r_q, r_j) ≥ 0.

It follows that (f^b₂(i) −f^b₁(i)) ≥ (f^b₂(i − 1) −f^b₁(i − 1)). That is, the difference is mono- tonically increasing as i increases.

By Lemma 4, for each q > p, at most one edge with right endpoint in V_q needs to be considered, and all the other edges in E_x can be eliminated. Let E_x⁰ = {f_i|1 ≤ i ≤ h} be the set of edges that should be taken into consideration, in which right(f_i) > right(f_i+1) for each i. Starting at F^b₁ =f^b₁, our algorithm iteratively computes F^b_i = min{F^b_i−1,f^b_i} for i from 2 to h, and by definition F_x=F^b_h.

Let p = α₀ < α₁ < . . . < α_t ≤ k. We denote the piecewise function F^b_i by S_t

j=1(α_j,f^b_g(j)), in which g(j) ≤ i andF^b_i(λ) =f^b_g(j)(λ) for each j and any λ ∈ [α_j−1+ 1..α_j]. We say that [α_j−1+ 1..α_j] is the j-th interval ofF^b_i.

Lemma 6: For any i, the function f^b_i intersects F^b_i−1 at most once. If they intersect,f^b_i must appear at the first interval ofF^b_i.

Proof: By definition, F^b_i−1 = min_j<if^b_j, and right(f_i) < right(f_j) for any j < i. By Lemma 5, the difference (f^b_i(λ) −f^b_j(λ)) is monotonically increasing as λ increases. That is, iff^b_i(λ) >F^b_i−1(λ) for some λ, we can conclude that f^b_i(λ⁰) >F^b_i−1(λ⁰) for any λ⁰ > λ, and the result follows.

Based on Lemma 6, the merging algorithm for computing F^b_i is designed as follows.

For convenience, letf (λ) = ∞ for any λ ≥ right(f ).^b

Algorithm Merge(F^b_i−1,f^b_i)

Input: An edge f_i = (x, y) and a piecewise function Fb_i−1=^St_j=1(α_j,f^b_g(j)) stored in a link list L.

Output: F^b_i stored in L.

1: if F^b_i−1(p) ≤ f_i(p)

2: return; /* no intersection */

3: Scan L from the head so as to find the smallest α_j such that Fb_i−1(α_j) < f_i(α_j);

4: Use binary search to find the intersection point λ in [α_j−1, α_j];

5: Remove all intervals before the j-th interval from L;

6: Break the j-th interval by inserting (λ − 1,f^b_i) at the head of L;

7: return L.

The algorithm for computing the swap costs for all edges in the path is as follows.

Algorithm Two SERT P

Input: A graph G = (V, E, w), a spanning tree T and two source vertices s₁ and s₂. Assume that G is stored in an adjacency list;

Output: χ(T, e) for each e in the path between the two sources;

1: Compute the following:

1.1: the path P = (r₀, r₁, . . . , r_k) between s₁ and s₂; 1.2: d_T(u, v) for any u, v ∈ V ;

1.3: for each vertex v do find i such that v ∈ V_i; 1.4: n_i= |V_i| and N_i= |V (Y_i)| for each i;

1.5: D_T(v, V_i) for each i and each v ∈ V_i;

1.6: D_T(v, Y_i) and D_T(v, ¯Y_i) for each vertex v and each i;

2: for each vertex x do

3: Find E_x by scanning the adjacency list;

4: Sort the edges f in E_x such that right(f ) are in a non-increasing order;

5: Construct E⁰_x= {f_i|1 ≤ i ≤ h} by eliminating the useless edges as described in Lemma 4;

6: F^b₁ ←f^b₁; and create a link list L with one element (right(f₁),f^b₁);

7: for i ← 2 to h do

Fb_i← Merge(F^b_i−1,f^b_i);

8: Compute F_x(i) for each e_i in P ; 9: for each e_i in P

Find χ(T, e_i) = min_xF_x(i);

Lemma 7: In algorithm Two SERT P, Step 1 can be done in O(n²) time.

Proof: It is obvious that Step 1.1 can be done in linear time. As shown in Lemma 4,

Steps 1.2–1.5 takes O(n²) time. Now let’s calculate the time complexity of Step 1.6 as follows. Observe that D_T(v, Y₀) = n₀d_T(v, r₀) + D_T(r₀, V₀) and that D_T(v, Y_i) = D_T(v, Y_i−1) + n_id_T(v, r_i) + D_T(r_i, V_i) for i > 0. Since all the required values are available before this step, D_T(v, Y_i) for all i can be done in O(n) time. Similarly, the distances D_T(v, ¯Y_i) for all i can also be found by an incremental method. Therefore, the total time complexity for Step 1 is O(n²).

The next result is straightforward by (1).

Lemma 8: After Step 1, the value δ(f, i) for any edge f and any i can be computed in constant time.

Lemma 9: The time complexity of algorithm Two SERT P is O(m log n + n²) time.

Proof: First, by Lemma 7, Step 1 can be completed in O(n²) time. Let’s analyze the time for the loop in Steps 2–8. Step 3 takes the linear time O(|E_x|), and the sorting at Step 4 can be completed in O(|E_x| log |E_x|) time. By Lemma 4, Step 5 can be also done in O(|E_x|) time. Step 6 takes only constant time. By Lemma 8, Step 8 takes O(n) time.

To analyze the time complexity of Step 7, we consider the Merge algorithm first.

In Merge, we check the intervals one by one until we find the intersecting interval.

Once the interval is found, a binary search is employed to find the intersecting point.

Obviously, the binary search needs at most O(log n) comparisons between the values of two functions. Since, by Lemma 8, the function values can be found in constant time, the binary search takes O(log n) time. To show the time complexity of Steps 3 and 5 in Merge, we use an amortized analysis. Let L_i denote the number of intervals of F^b_i and β_i denote the number of intervals checked while mergingf^b_i. We have that

L_i = L_i−1− β_i+ 2.

Summing up for i from 2 to h, we obtain

L_h = L₁−^X

i

β_i+ 2(h − 1).

Since L_h≥ 1 and L₁ = 1, X

i

β_i = L₁+ 2(h − 1) − L_h≤ 2h − 2.

That is, the total number of checked intervals is O(|E_x⁰|). Since checking for an interval takes only constant time by Lemma 8, the total time complexity of Step 7 in Algorithm Two SERT P is O(|E_x⁰| log n).

In summary, the time complexity of the whole loop for each x is O(|E_x| log |E_x|).

Since^P_x∈V |E_x| = m, summing up for all vertices, the total time complexity of the loop is O(m log n). Finally, since Step 9 can be easily done in O(n²) time, we conclude that the total time complexity of the algorithm is O(m log n + n²).

The next theorem summarizes the result in this section, which directly follows Lem- mas 3 and 9.

Theorem 10: The two-sources SERT problem can be solved in O(m log n + n²) time.

4 Multiple-sources case

In this section, we consider the case where there are more than two sources. By def- inition, the routing cost of a tree T with source set S can be calculated by c(T, S) = P

s∈SD_T(s, V (T )). Since there is no limit on the number of sources, a direct method for computing the routing cost of a tree will take O(n²) time even when the all-to-all distances are already known. For each edge e in E(T ), if we compute c(T_e/f, S) for every f in the cut set, the time complexity for finding the swap cost χ(T, e) will be up to

O(mn²), and consequently it takes O(mn³) to find the swap costs for all edges in T . We shall present an O(mn) time algorithm for the SERT problem with multiple sources.

First we introduce a new formula for computing the routing cost of a tree. Let e = (u₁, u₂) ∈ E(T ). As mentioned previously, removing e from T will result in two subtrees. Let T₁ and T₂ be the two subtrees, in which u₁ ∈ V (T₁). Let V_i = V (T_i) and E_i = E(T_i) for i = 1, 2. Let S₁ and S₂ denote the sets of sources in V₁ and V₂, respectively.

Apparently, there are |S₁| × |V₂| paths from a source in S₁ to a vertex in V₂. Similarly the number of paths from a source in S₂ to a vertex in V₁ is |S₂| × |V₁|. By defining the routing load l(T, e) = |S₁| × |V₂| + |S₂| × |V₁|, we have the following formula.

c(T, S) = ^X

e∈E(T )

l(T, e)w(e). (3)

The routing cost of an edge e is defined by l(T, e)w(e). The above property shows that the routing cost of T can be calculated by summing up the routing costs of all the tree edges. Based on (3), we can compute the routing cost of a tree in O(n) time when the routing costs of all edges are available. All we need to know is the routing load of each edge. By rooting T at an arbitrary vertex and traversing the tree in post-order, we can easily compute the numbers of sources and the numbers of vertices in both sides of every edge. Thus, the routing loads of all edges can be obtained in O(n) time.

To solve the multiple-sources SERT problem, our algorithm finds the swap cost of each edge individually. For each edge e, we calculate the routing cost of T_e/f for each edge f crossing the cut. We shall show that, after a preprocessing stage, the routing cost of T_e/f can be computed in constant time.

For any edge f ∈ C(e), by (3), we have

c(T_e/f, S) = ^X

e⁰∈E1

l(T_e/f, e⁰)w(e⁰) + l(T_e/f, f )w(f ) + ^X

e⁰∈E2

l(T_e/f, e⁰)w(e⁰), (4)















Figure 3: Y_v is the subtree of Y rooted at a vertex v.

in which l(T_e/f, f ) = l(T, e) since e and f are crossing the same cut.

To reduce the computation time, one difficulty is that the routing load of an edge p in a tree T_e/f is not fixed but depends on f . The following simple observation is crucial for our algorithm. For each edge e⁰ ∈ E(T ) − {e}, there are only two possible values of l(T_e/f, e⁰) for all f ∈ C(e), depending on which side of e⁰ the swap edge f is connected to.

In the following, we shall give a procedure for computing function γ₁(e, v) for each v ∈ V₁, which is defined to be the total routing cost of all edges in E₁ subject to that the swap edge f is connected to v. By a similar procedure, we can compute function γ₂(e, v), which is defined to be the total routing cost of all edges in E₂ subject to that the swap edge f is connected to v. Once the two functions are completed, the routing cost of T_e/f for any f can be calculated in constant time.

Let Y be the tree obtained by rooting T₁ at u₁. By Y_v, we denote the subtree of Y rooted at a vertex v. For an edge (u, v) ∈ E(Y ), we assume that u is the parent of v in Y , as shown in Figure 3.

Let n_v and s_v denote the numbers of vertices and sources, respectively, in the subtree

Y_v. For any e⁰ = (u, v) ∈ E(Y ), define

¯l₁(e⁰) = (s_v(n − n_v) + (|S| − s_v)n_v)w(e⁰), (5)

which is the routing cost of e⁰ if the swap edge is connected to any vertex not in V (Y_v).

Similarly, define

¯l2(e⁰) = ((s_v+ |S₂|)(|V₁| − n_v) + (|S₁| − s_v)(n_v+ |V₂|))w(e⁰), (6)

which is the routing cost of e⁰ if the swap edge is connected to any vertex in V (Y_v).

Then, by definition, the value γ₁(e, v) can be calculated by

γ₁(e, v) = ^X

e⁰∈P/

¯l₁(e⁰) + ^X

e⁰∈P

¯l₂(e⁰),

in which P is the path between v and the root u₁. Clearly, for the root u₁,

γ₁(e, u₁) = ^X

e⁰∈E(Y )

¯l1(e⁰), (7)

and, for any child v of a vertex u,

γ₁(e, v) = γ₁(e, u) − ¯l₁(u, v) + ¯l₂(u, v). (8)

By (7) and (8), we can compute γ₁(e, v) for all vertices v in Y by traversing Y twice: a post-order traversal for computing γ₁(e, u₁), and then a preorder traversal for computing γ₁(e, v) from the value of its parent for every other vertex v. The whole algorithm is as follows.

Algorithm Multiple SERT

Input: A graph G = (V, E, w) and a spanning tree T and the source vertex set S.

Output: χ(T, e) for each e ∈ E(T ).

1: for each tree edge e = (u₁, u₂) do

2: Find the two subtrees T₁ and T₂; 3: Construct Y by rooting T₁ at u₁;

4: Traverse Y in a post-order to find s_v and n_v for each v;

5: Compute ¯l₁(e⁰) for each e⁰ ∈ E(Y ) by (5);

6: Compute ¯l₂(e⁰) for each e⁰ ∈ E(Y ) by (6);

7: Compute γ₁(e, u₁) =^P_e0∈E(Y )¯l₁(e⁰) by traversing Y in a post-order;

8: Traverse Y in a preorder to find γ₁(e, v) by (8) for each v ∈ V₁− {u₁};

9: Use the steps similar to Steps 3–8 to find γ₂(e, v) for each v ∈ V₂; 10: for each f = (x, y) ∈ C(e) do

c(T_e/f) ← γ₁(e, x) + l(T, e)w(f ) + γ₂(e, y) 11: Find χ(T, e) = min_fc(T_e/f).

Theorem 11: The multiple-sources SERT problem can be solved by Multiple SERT in O(mn) time.

Proof: The correctness follows directly from the above explanation. It remains to show the time complexity of Multiple SERT is O(mn). Clearly, Steps 2–9 can be done in O(n) time. The time complexity of Steps 10 and 11 is O(m). Since there are n − 1 edges in the tree, the total time complexity is O(mn).

5 Concluding Remarks

In this paper, we propose algorithms for finding the swap cost of every edge of a multiple- sources routing tree. Our algorithms take O(m log n + n²) and O(mn) time for the two- sources case and the multiple-sources case, respectively. It is easy to see that the swap edges have been implicitly found by the algorithms.

The algorithms developed in this paper can be easily extended to the case of weighted routing cost, in which we are given a nonnegative weight r(v) for each vertex v, and the routing cost of v is defined by r(v)D_T(v, S). Note that it includes the case that not all vertices are destinations by setting zero weight to vertices which are not destinations.

The swap edge problem we defined in this paper is to minimize the total, or equiv- alently the average, length of every path from a source to a destination. We are also interested in the swap edge problem with respect to other criteria [4, 7]. Another inter- esting problem about survivability is to find the most vital edge of a shortest path or a minimum spanning tree [2, 5, 6].

Acknowledgements

We thank the reviewers for their helpful comments. Bang Ye Wu was supported in part by NSC grants 93-2213-E-366-001 and 93-2213-E-366-014, Taiwan. Chih-Yuan Hsiao and Kun-Mao Chao were supported in part by NSC grants 92-2213-E-002-059 and 93-2213- E-002-029, Taiwan.

References

[1] A. Di Salvo and G. Proietti, Swapping a failing edge of a shortest paths tree by minimizing the average stretch factor, (SIROCCO’04), LNCS 3104, 99–110, 2004.

[2] B. Dixon, M. Rauch, and R.E. Tarjan, Verification and sensitivity analysis of mini- mum spanning trees in linear time, SIAM Journal on Computing, 21(6), 1184–1192, 1992.

[3] M. Gr¨otschel, C.L. Monma, and M. Stoer, Design of survivable networks, Handbook in OR and MS, Vol.7, Elsevier, Amsterdam, 617–672, 1995.

[4] G. F. Italiano and R. Ramaswami, Maintaining spanning trees of small diameter, Algorithmica, 22(3), 275–304, 1998.

[5] K. Iwano and N. Katoh, Efficient algorithms for finding the most vital edge of a minimum spanning tree, Information Processing Letters, 48(5) , 211–213, 1993.

[6] E. Nardelli, G.Proietti, and P. Widmayer, A faster computation of the most vital edge of a shortest path, Information Processing Letters, 79(2), 81–85, 2001.

[7] E. Nardelli, G.Proietti, and P. Widmayer, Swapping a failing edge of a single source shortest paths tree is good and fast, Algorithmica, 35(1), 56–74, 2003.

[8] B.Y. Wu, A polynomial time approximation scheme for the two-source minimum routing cost spanning trees, Journal of Algorithms, 44, 359–378, 2002.

[9] B.Y. Wu, Approximation algorithms for the optimal p-source communication span- ning tree, Discrete Applied Mathematics, 143, 31–42, 2004.

[10] B.Y. Wu and K.-M. Chao, Spanning Trees and Optimization Problems, Chapman

& Hall / CRC Press, 2004.

[11] B.Y. Wu, K.-M. Chao, and C.Y. Tang, Approximation algorithms for some optimum communication spanning tree problems, Discrete Applied Mathematics, 102, 245–

266, 2000.

[12] B.Y. Wu, G. Lancia, V. Bafna, K.-M. Chao, R. Ravi and C.Y. Tang, A polynomial time approximation scheme for minimum routing cost spanning trees, SIAM Journal on Computing, 29, 761–778, 1999.