A distributed algorithm for constructing an Eulerian tour

Transcription

1 A distributed algorithm for constructing an Eulerian tour S. A. M. Makki School of Information Technology The University of Queensland Queensland 4072 A us t r ali a sam@cs.uq.edu.au Abstract We present an efficient distributed algorithm for constructing an Eulerian tour in a network. To construct an Eulerian circuit the algorithm requires (1 + r)(iei + IVl) messages and time units, where IEI is the number of the communication links, IVl is the number of the nodes in the underlying network graph, and 0 5 r < 1. The value of r depends on the network topology and on the chosen traversal path. In the best case, when r = 0 the algorithm only requires (IEI + IVl) messages and time units. A simple modification allows us to construct a (noncyclic) tour using (1 + r)(iei + 2lVl) messages and time units. Keywords: Distributed systems, Eulerian tour, Communication graph. 1 Introduction The problem of finding an Eulerian tour in a connected graph in a centralized environment has been studied by many researchers. However in a distributed environment the problem has different complexity measures. Descriptions of algorithms for constructing an Eulerian tour in a centralized environment can be found in the literature [2,6,7, 131. In these algorithms the processor which constructs the Eulerian tour stores the graph structure in one location, while in a distributed environment the graph structure is distributed among different processors which have to construct the Eulerian tour. The Eulerian tour (cyclic or noncyclic) has practical application in different areas such as scheduling and routing. Many routing problems involve finding a path or circuit that minimizes traversing a set of edges in a graph, such as the Chinese Postman Problem (in which a postman wishes to minimize his tour for delivering the daily mail) [4, 81; also, Eulerian tours can be used in designing telecommunications systems, decoding genetic information and computer graph plotting [14]. We recall some of the basic graph definitions [9]. A walk in a graph G is an alternating sequence of vertices and edges VO, 21, VI,..., vn-l, x,, v, beginning and ending with vertices, in which each edge is incident with the two vertices immediately preceding and following it; n is the length of the walk. A tour or path is a walk with no repeated edges. A walk is closed if the initial vertex is the same as the terminal vertex. A circuit is a closed walk in which each edge is used exactly once. Such a circuit (or tour which uses each edge) is known as Eulerian. Any graph that contains an Eulerian tour is called an Eulerian graph. For finite connected graphs an Eulerian circuit can be constructed if and only if every vertex of the graph has even degree. In fact an Eulerian circuit may regarded as a union of edge-disjoint circuits, as is shown by the algorithm at the end of this section. For finite connected graphs with two odd degree vertices only noncyclic Eulerian tours can be constructed, in which the odd degree vertices are the start and the end nodes of the tour. Euler was the first who established the condition for such a tour and investigated the existence of such a tour in finite connected graphs. He provides a proof of a necessary condition for a connected graph to be Eulerian and stated its sufficient condition (the existence of an Eulerian tour in a connected graph with no vertices of odd degree, or two such vertices). The proof of the sufficient condition was given independently by Hierholzer [I, pp 1-20]. These two results establish the basic characterization of Eulerian graphs. A complete survey of characterizations of Eulerian graphs is given by Lesniak and Oellermann [ll]. (For infinite connected graphs the existence of an Eulerian tour is harder to characterize. Some results on infinite Eulerian graphs can be found in the literature [5, 15, pp 77-80].) /97 $ leee 94

2 The rest of this paper is organized as follows. First we present a model and in the next section we describe two centralized algorithms for construction of an Eulerian tour. Then in section 4 our new distributed algorithm is presented with an example of its performance on a sample network topology. In section 5 we present a formal description of the algorithm. In section G we analyze the complexity of the algorithm and prove its correctness in section 7. The final section presents the concluding remarks, and high level pseudo-code for the algorithm is presented in an Appendix. 2 Themodel A distributed system can be modeled by an undirected communication graph G = (VI E), where V is the set of sites and E is the bidirectional links of the communication network. It is assumed that each site has a unique identity. Sites do not have information on the global network structure. They have only local information, such as the identities of their neighbors together with local variables for storing data. Message delivery is handled by the communication subsystem which delivers a message from sender to receiver in a finite time without any alteration or loss. A receiving site keeps messages in arbitrary order till they can be processed. Receiving and processing a message needs negligible time. We evaluate the complexity of our algorithm using standard complexity measures. The communication complexity is the total number of messages sent during the execution of the algorithm. The time complexity is the maximum time elapsed from the beginning to the termination of the algorithm, assuming that delivering a message over a link requires at most one unit of time. It is assumed that no link or process failure occurs during the execution of the algorithm. 3 Preliminary One of the earliest algorithms to construct an Eulerian tour in a graph G is presented by Fleury [lo, 3, 131. It has 0(lEl2) complexity. It is an easy and simple way of constructing an Eulerian tour. In this algorithm the graph is searched repeatedly. The algorithm as described by McHugh [13, p. 421 is as follows: 1- Start from a vertex s, erasing traversed edges and any resulting isolated vertices as the algorithm proceeds. 2- Never traverse an edge if at that particular moment the removal of this edge would disconnect the remaining graph into nontrivial components before all the edges are traversed. Thus, Fleury s algorithm repeatedly extends an incomplete Eulerian tour T from its terminal vertex v by appending to T any edge incident with v which is not a bridge of G - T and whose removal would not isolate the starting vertex before all the edges are traversed. Since it takes O(lE1) time to test whether an edge is a bridge, each edge only has to be tested once, and there are IEl edges in GI it follows that the algorithm has 0(lEl2) complexity Thereafter many researchers presented different algorithms which construct an Eulerian tour in O(lE1) time complexity. Below is an algorithm described by Evans and Minieka [6, p which is based on the Eulerian characterization theorem (i.e. a graph has an Eulerian circuit if and only if each vertex has even degree). This algorithm constructs an Eulerian circuit in an Eulerian graph G in O(lE1) and is as follows: 1- Select an arbitrary node as the start node s. From this node construct an arbitrary circuit CO by first traversing any edge (s, U) incident to node s. The edge (s, U) is marked as traversed, then from a traverse an edge which is not traversed before. Repeat the process until the traversal returns to s. The process will return to s because the nodes have even degree and each time a node is visited an even number of edges is used (to enter and to leave). Therefore, every time the traversal reaches a node except possibly the start node, there is an edge to exit from that node. 2- The algorithm stops if the constructed circuit CO contains all the edges of G. Otherwise the remaining subgraph G1 = G - E(C0) must be Eulerian, because each node of circuit CO contains an even number of edges. The subgraph GI and CO must have at least a common node, v say, since G is a connected graph. 3- Construct a circuit C1 in subgraph G1 from U. Then insert the constructed circuit C1 after U in circuit CO and return to step 2. A simple modification handles graphs with two odd degree vertices to give an Eulerian tour (which is not a circuit). The algorithm starts at either of the odd degree vertices and finishes at the other. 4 The algorithm To construct an Eulerian tour in a distributed environment, we modify the above centralized algorithm described by Evans and Minieka. This centralized 95

3 algorithm only considers graphs which contain an Eulerian tour and does not investigate the existence of such a characteristic. For a distributed environment we incorporate such an investigation explicitly into our algorithm, which makes the algorithm self-contained. Therefore the proposed Eulerian algorithm consist of two parts. The first part checks for the existence of an Eulerian tour in the graph G. Then, depending on the result, if such a tour exists the second part constructs an Eulerian tour. In order to investigate if an underlying network graph is Eulerian we use a modified variant of a graph traversal algorithm. We modify the depthfirst search algorithm described in [la] by adding to their messages a parameter which keeps track of odd degree vertices (the modification is trivial, therefore the implementation details are not provided here). This traversal algorithm is selected since it requires less than 2lVl messages in its worst case. As a result it does not adversely effect the complexity of the proposed Eulerian algorithm. For brevity the modified depth-first search algorithm and the algorithm for construction of the Eulerian tour are denoted Mddfs and det, respectively. The Mddfs algorithm is shown as the procedure Check-Graph-Is-Eulerian() in the pseudo-code of Figure 2. The variable Eulen an in this procedure returns the result of applying this procedure to the corresponding graph. This variable can return one of three values: no Eulerian tour; Eulerian tour with identified end nodes, (either one can be the start node with the other as the end node); or, Eulerian circuit (in which any node may be the start node). To construct the Eulerian tour we use two types of messages, forward and backtrack, in an analogy with forward and backtrack steps used in the centralized algorithms. The centralized Eulerian algorithm described by Evans and Minieka is an efficient algorithm for a centralized environment. However a straight forward modification does not yield an efficient algorithm for a distributed environment. Hence our aim is to enhance the performance of the modified centralized algorithm in a distributed environment. The basic idea is to reduce the number of backtruck messages by using dynamic backtracking (with the same philosophy as in [la]) and (in addition) to terminate the algorithm after all the edges are traversed, without any need to return to the start node. These techniques reduce the number of backtrack messages significantly. In order to achieve this efficiency we include in our messages the information which indicates the potential return node address (returnadd) and the total number of unused (not traversed) edges (Tunu~) of the nodes visited so far. Therefore the messages contain four types of parameters: messagetype (forward or backtrack); originator; Tunu~; and returnadd address. Returnadd is the address of the node to which a backtrack message can be directed. For each node this address is either the sender of the forward message or, if the sender does not have any unused edge, it is the sender s returnadd address. As a result the backtrack messages are able to by-pass intermediate nodes of a current circuit which do not have any unused edges (since a circuit may contain simple cycles). TunuE allows the algorithm to terminate when all the edges are traversed. Consider an underlying network graph G. Select a node as the stad node, which sends a forward message to one of its neighbors (randomly selected). The receiver subsequently selects an unused edge and repeats the same procedure. To traverse all the edges, each node has to send or receive forward messages to or from its neighbors at one time. In the process each edge is numbered from 1 to the node s degree. For this purpose each node keeps a local counter which is set to zero at the start of the algorithm and is incremented whenever the node sends or receives a forward message. A node that receives a forward message for the first time will number the incoming edge as number 1, increment the counter, select one of its edges as number 2 and send a forward message through this edge to the attached neighbor. Via each edge only one forward message can be sent or received until all the edges of the node have been numbered. Traversing a graph with random selection of edges may create a situation where some or part of a graph can be isolated from the rest of the graph. This means that traversal can reach a node from which it can not proceed further, since the corresponding node does not have any unused edges. However there may be some unvisited nodes remaining in another part of the graph. This could have been prevented, if another path had been selected. In order to select an alternative path the order in which the nodes send their forward messages must be changed. Recall that the edges are numbered when sending or receiving their forward messages. As mentioned earlier, all the communication edges and counters are set initially to zero. Thus when all the edges of the underlying graph are numbered the desired Eulerian tour has been established. However, if all the edges of the underlying graph have not been numbered, the traversal must have visited a 96

4 node, 20 say, where another edge could have been selected (because of connectivity). Then, in order to reach w, backtrack messages have to be sent along the traversed path until the traversal returns to w. At this node the number of the edge that has resulted in tliis terminating path must be changed. This edge s number is replaced with a number equal to the node degree, which implies that this is the last edge to select. The reason for this is so that next time when the traversal reaches w, it will not select the terminating path again, but select another unused edge at this node or backtrack to a node which has an unused edge. After termination of the algorithm each node has Figure 1: graph G numbered its edges in such a way that an Eulerian tour can be constructed by following - the edge - numbers at each node. The algorithm does not need to terminate of d). Then it selects another unused edge, marks it at the start node. The algorithm begins from an number 2. It continues the process until either all arbitrary node as the start node which sets the variable the edges of the graph are numbered or the traversal initial to True and gives to itself a forward message reaches a node which does not have any unused edges, containing itself as the originator and zero for Tunu~. where the traversal must backtrack again. The algorithm is sequential in a sense that at most one node is executing its version of the algorithm at any Say the algorithm arbitrarily constructs from d one time, which makes the contents of the message, in the circuit (d, f, k,j,p, q,j,d). At this time traversal effect, global. Pseudo-code is presented in Figure 2. can not continue any further, since d does not have The performance of the algorithm is illustrated with any unused edges. Therefore it must backtrack from a simple example. d to a node which has unused edges. The return 4.1 Example Consider the 16 node graph in Figure 1. Select s as the start node. The degree of all the vertices in this graph is even. Depending on the order of the traversed edges, an Eulerian tour can be constructed by traversing all the edges. (Note that a graph may have more than one Eulerian tour starting at a particular node.) The algorithm randomly selects an edge, (s, U) say, numbers this edge 1, assigns to Tunu~ the number of its unused incident edges. Then it sends a forward message to node a. Node a assigns edge (s,a) as number 1, since this is its first incoming edge. Then it selects randomly edge (a,d), numbers this edge 2, and sends a forward message to node d. The same procedure is repeated at d, so that a circuit, (s, a, d, s), is constructed. At this stage because s does not have any unused edges and the total number of unused edges Tunu~ is not zero, therefore the search must backtrack to a node with unused edges. So s sends a backtrack message to d. Node d receives the backtrack message and changes its future traverse order by replacing the edge (d,s) number from 2 to 4 (the highest available number, which is the degree address for d in this path is q, but q is not its neighbor so it has to backtrack via j (the sender of forward message to d). This backtrack message does not change the ordering number of the used edges at j, since j does not have any unused edges left. Then it backtracks from j to q as shown with dotted arrows in Figure 1. The backtrack message at q changes the ordering number of the last used edge, since q has some unused edges. Therefore it renumbers its last used edge. Then traversal continues from q to create the next arbitrarily chosen circuit (n, 2, m, g, b, c, h, n, Y, 2, n, m, h, Q >. At this stage traversal needs to backtrack to h which is the return address for q, as q and other nodes between h and q in the forward direction in this circuit do not have any unused edges. Therefore from q traversal backtracks to L, m and n. The intermediate node n has node h as its return address and its neighbor. Therefore the traversal can backtrack directly to h instead of backtracking via (n, E, y, n) which, as a result, saves three backtrack messages as shown in Figure 1. Because h has unused edges, it has to change the number of edge (h,n) from 2 to 4. Then it selects the edge (h, b) as its number 2 and sends aforward message to b. Traversal continues from b until it returns to h which constructs another circuit 97

5 (h,b,a, f,g,h). At this stage Tunu~ is zero, therefore all the edges of the graph have been numbered and the algorithm terminates. Now if the edges are traced in the number order in which they have been organized, (sadjk jpqxmgbchbafghnyxnmkqjds) an Eulerian tour is constructed. 5 Formal description of the algorithm Each node has a copy of the procedure EulerTour, for which pseudo-code is given in Figure 2. The algorithm starts from an arbitrary node as the start node which gives to itself a forward message. The start node initializes counterj, its forward counter, to -1 and sets Tunu~ to the total number of its incident edges, since this message is issued by the start node to itself. Then it executes the procedure Check-Graph- Is-Eulerian which is executed once only, by the start node. This procedure investigates the existence of an Eulerian tour in the underlying graph structure and at each node sets the variable initial to True. If the underlying graph has two odd degree vertices this procedure starts the construction of an Eulerian tour from either of these two odd degree nodes. The rest of the local variables for each node are initialized when a node receives its first forward message. Each node also keeps a counter for incoming forward messages and two sets (used, unused) for the traversed and not yet traversed edges. The variable TunuE, which is the total number of unused edges of the nodes visited so far, controls the progress of the algorithm. Two stack structures fsender and returnadd keep track of the incoming forward messages and their return addresses for each node. The return address for each node can be either the sender of its forward message, or the address of an earlier node which has some unused edges. 6 Complexity Analysis Theorem 1: To construct an Eulenan circuit, the proposed algorithm uses (1 +.)(!El + IVl) messages and time units, where IEI as the number of the communacatzon lanks, IVI is the number of the nodes m the underlyzng network graph, and 0 5 T < 1. Proof: The proposed algorithm contains two parts. The first part checks for the existence of an Eulerian tour by using the Mddfs algorithm which is a modified version of distributed depth-first search (ddfs). The best case and the worst case complexity of ddfs are IVI and (1 +.)[VI, respectively, as shown in [12]. The second part constructs the Eulerian circuit, where all the edges of the underlying network graph must be traversed. So each edge needs to send or receive a forward message. Each edge transfers only one forward message, as each edge is numbered only once and the edge renumbering steps in the algorithm prevent forward messages from traversing an edge more than once. Therefore the number of forward messages is the same as the number of edges. In the worst case, the algorithm needs to use backtrack messages, since the search may reach a node which must backtrack in order to traverse all the edges. In this case the Eulerian tour will be constructed by combining smaller circuits. At each step when a circuit is constructed the message variable Tutau~ is checked. If it is zero then all the edges of the graph are used and the algorithm terminates. Otherwise the algorithm must backtrack to a visited node which has unused edges, in order to construct the other circuits. The returnadd is capable of directing the search to such a node. As a result the backtrack messages do not traverse all the edges. Furthermore the algorithm does not require to terminate where it starts. So the number of backtrack messages is always less than the number of the edges. As a result the total number of required forward and backtrack messages is less than 21EI. Because the algorithm sequentially visits each edge, the time complexity of the algorithm is also less than 21EI units of time since transmitting a message requires at most one unit of time. Although the first part (Mddfs algorithm) and the second part (det algorithm) may not have the same best case for a given topology, the best case complexity of the complete algorithm occurs as the result of combination of the best cases of the two parts. In the best case, an optimal ddfs construction is followed by backtrack-free traversal of Eulerian circuit. This always happens for a ring topology, for example. In such cases the total number of messages and time units required is!vi+ IEl. Theorem 2: To construct a noncyclic Eulerian tour, the proposed algorithm uses (1 +.)([El + 2lVl) messages and tame units, where IEI is the number of the communication links,!vi is the number of the nodes in the underlying network graph, and 0 <_ r < 1. Proof: If the underlying graph has two odd degree nodes and the start node is not either of these two nodes an extra stage is needed between the Mddfs and det parts. A starting message needs to be sent to one of the odd degree vertices. This can be done 98

6 by another simple modification of the ddfs algorithm, requiring at most 21VI extra messages. 7 Correctness To prove the correctness of our algorithm, first we have to prove that the algorithm terminates and after termination all the edges of the graph are used. Finally we show that the obtained numbering provides an Eulerian tour for the underlying network graph. Theorem 3: The algorithm traverses all the edges and terminates after all the edges of the network graph are used. Proof: When all the edges incident to the start node s have sent or received their forward messages a circuit such as CO = (S, XI, X2,... Xj-1, Xj, Xj+l,..., Xk, S) is constructed. At this stage the last node of the circuit checks the message variable Tunu~, which is the number of unused edges of visited nodes so far. If it is zero, then all the edges are used and the algorithm terminates. Otherwise the traversal must backtrack to a node, say x,, which has unused edges. Then the node xj selects one of its unused edges and sends a forward message to its neighbor. As a result another circuit, say Cl = (xj, ul, u2,..., al, xj) will be constructed. Then the circuit C1 is inserted in CO by the renumbering step explained in the algorithm. The unsuccessful used edge changes its number and will be the last edge to be traversed from that node. As a result a bigger circuit has been constructed in which each edge appears in this circuit only once, CO = (s, XI, XZ,..., xj-1, zj, UI, a2,... j ar, zjt zj+l, - 1., xk, s). Now if the obtained tour contains all the edges, (through checking of the message variable Tunu~), the algorithm terminates, otherwise the same procedure is repeated until all the edges are used. Theorem 4: The obtained numbering provides an Eulerian tour. Proof: The edges of each node are numbered in a way that, starting from the start node, a tour is constructed which contains all the edges of the underlying graph exactly once. 8 Conclusion A distributed algorithm for constructing an Eulerian tour in a network has been presented. The algorithm requires less than 2( IEl+2lVl) messages and time units (which can be interpreted as (1 + r)(iei + 21V/) messages and time units), where 0 5 r < 1, IEI is the number of the communication links and IVl is the number of the nodes in the underlying network graph. The value of r depends on the network topology and on the routing chosen. In the best case, when r = 0, the algorithm only requires [El + [VI messages and time units to construct an Eulerian circuit. The algorithm is practical and easy to implement. A simple variant of this algorithm can be used to construct an Eulerian tour in a directed graph. Ideas in this algorithm are also applicable to other algorithms for centralized and distributed systems. References [l] N. Biggs, E. K. Lloyd, R. J. Wilson. Graph Theory Clarendon Press, [2] G. Chartrand, 0. R. Oellermann. Applied and Algorithmic Graph Theory. McGraw-Hill, Inc., [3] N. Christofides. Graph Theory, An Algorithmic Approach. Academic Press, [4] J. Edmonds, E. L. Johnson. Matching, Euler Tours and the Chinese Postman. Mathematical Programming, 5:88-124, [5] P. Erdijs. Graph Theory and Probability. Canadian Journal of Mathematics, 11:34-38, [6] J. Evans, E. Minieka. Optimization Algorithms for Networks and Graphs. Second Edition, Marcel Dekker, Inc , [7] S. Even. Graph Algorithms. Computer Science Press, [8] M. GrGtschel, L. Lovbz. Combinatorial Optimization: A survey, Technical Report 93-29, DIMACS Rutgers University, New Jersey, USA, May [9] F. Harary. Graph Theory. Addison-Wesley Publishing Company, [lo] A. Kaufmann. Gmph, Dynamic Programming and Finite Games. Academic Press, [ll] L. Lesniak, 0. R. Oellermann. An Eulerian Exposition. Journal of Graph Theory, 10(3): , [12] S. A. M. Makki, G. Havas, Distributed algorithms for a depth-first search. Information Processing Letters, to appear. [13] J. A. McHugh. Algorithmic Graph Theory. Prentice- Hall, [14] F. S. Roberts. Graph theory and Its applications to Problems of Society. Regional Conference Series in Applied Mathematics, 29:65-77,

7 [15] R. J. Wilson. Introduction to Graph Theory. Second Edition, Longman Group Limited, Appendix 1 procedure EulerTour; { executed on receipt of FORWARD or BACKTRACK messages } const 2, edgeset, neighbours, degree; var 3, k, n, edge, root, counterf, znitial:= True; var fsender, returnadd, used, unused; { local variables } var messagetype, orzgznator, Tunu~, Msg-returnadd, EuZerzan; { message variables } begin if NOT initial do { node is visited for the first time } TunuE := TunuE - 1; { update totd unused edges } initeal := FALSE; used := 0; initialize local variables } if i = root do { node is the start node } Check-Graph-Is-Eulerian( ); { Checks number of odd degree nodes to satisfy Eulerian condition (zero,or two)} if NOT Eulerian do STOP { terminates since it is not an Eulerian topology } if Eulerian Path do { only Eulerian path exist } Start the algorithm from either of the two identified odd degree vertices Tunu~ := ledgesetl; counterf := -1; { initialize local variable } counterf := 0; TunuE = TunuE + ledgeset1-1; { update the total unused edges so far } if messagetype = FORWARD do Subs-Forward( ); Subs-Backtrack( ); end Figure 2: Pseudo-code of the algorithm for node i Subs-Forward() begin edge[originator] := + + counterf; if ( i!= Msg-returnadd ) do if ( returnadd.val!= Msg-returnadd ) do push(returnadd,msg-returnadd); { save return } push(fsender,orkginator); { save originator } { originator does not have any unused edge } Msg-returnadd := returnadd.va1; used := used U {edgere]}; unused := edgeset - (used n edgeset) ; if (unused # 0) do { unused edge exist } j := Next(unused); { get next unused edge } TunuE := TunuE - 1; if (unused- {j} # 0) do Msg-returnadd:= i; { update message return address } issue FORWARD message to node j; used := used U {j}; unused := edgeset - (used n edgeset) ; edge[j] := + + counterf; { time to terminate or backtrack } if (Tunu~ = 0) do { no unused edge exist } STOP { Terminate, since all edges are used } { need to backtrack } if(returnactd.val E neighbors) do issue BACKTRACK message to returnadd.val; issue BACKTRACK message to fsender.uol; pop(returnadd, returnadd.vaz); pop(fsender, fsender.uai); end Subs-Backtrack() begin if (returpzadd.val == originator) do pop(returnadd, originator); pop(fsender, fsender.val); { remove traversed cycle } Msg-returnadd := returnadd.va1; if (unwed # 0) do { unused edge exist } Tunu~ := TunuE - 1; edge[counterj] := degree; j := Next(unused); edgeb] := counterf; if (unused- {j} # 0) do Msg-returnadd:= i; issue FORWARD message to node j; used := used U {j}; unused := edgeset - (used n edgeset) ; { need to backtrack } end if (returnadd.vat E neighbors) do issue BACKTRACK message to returnadd.va1; issue BACKTRACK message to fsender.val; pop(returnadd, returnadd.val); pop(fsender, fsender.vaz); 100