Algorithms for External Memory Lecture 6 Graph Algorithms - Weighted List Ranking

Transcription

1 Algorithms for External Memory Leture 6 Graph Algorithms - Weighted List Ranking Leturer: Nodari Sithinava Sribe: Andi Hellmund, Simon Ohsenreither 1 Introdution & Motivation After talking about I/O-effiient tree algorithms in the previous letures, we started the last topi of the external memory setion, that is I/O-effiient graph algorithms. The problem addressed in this leture is to ompute the weighted list rank of a linked list. Before motivating the need for I/O-effiient algorithms for linked lists, we will shortly reap some of the basis from graph theory letures. A graph is a tuple G = (V, E) with V being the set of nodes of the graph and E being the set of edges (u, v), u, v V between nodes u and v. The degree deg(v) of a node represents the total number of inoming and outgoing edges; for direted graphs we may further distinguish between deg in (v) as the number of inoming edges and deg out (v) as the number of outgoing edges of a node. A singly, non-irular linked list is a linear graph with eah node v having deg in (v) = deg out (v) = 1 assuming markers for the start and end of the list as shown figure 2. The rank rank(v) of a node in a linked list is defined as the number of edges that need to be traversed from the beginning of the list to reah node v. Finally, the weighted list ranking problem is desribed as the proess to ompute a per-node (or per-edge), umulative sore based on node (or edge) weights as shown in figure 1. In the trivial ase of all weights being 1, the per-node sore represents the rank of a node. Figure 1: Example for Weighted List Ranking Considering linked lists and the list ranking problem from the I/O perspetive, the problemati aspets of its simpliity are the next pointers targeting arbitrary memory loations as shown in figure 2. Using our ommonly used external memory model as introdued in leture 1 with M being the size of the internal memory and B being the size of bloks transferred between internal and external memory, traversing this linked list requires a single I/O per visited node for B = 2 and M = 2B. This shows that the upper bound of simple list traversal 1

2 Algorithms for External Memory 2 Figure 2: Generi Linked List with Distint Non-Node Markers for the Start and End of the List for solving the list ranking problem is O(N) I/O operations for a list with N nodes. In this ontext, remember the omplexity notation used throughout this leture: O(san(N)) = O( N B ) < O(sort(N)) = O(N B log M B N B ) O(N) 2 Weighted List Ranking In this setion, we present an I/O-effiient algorithm to solve the weighted list ranking problem with an I/O omplexity of O(sort(N)) 1. Before presenting the final list ranking algorithm and its I/O omplexity analysis, we will firstly introdue - as a prerequisite - two algorithms to (a) ompute a pairwise sum funtion (PSF) for eah node of the linked list and (b) to find an independent set of the linked list with a speifi size. We will also show that both algorithms require O(sort(N)) I/O omplexity. 2.1 Computing Pairwise Sum Funtion (PSF) In the ontext of solving the weighted list ranking problem, we will only onsider pairwise sums as umulative sore, but the problem statement is generalized as follows. Assuming a linked-list L = (V, E) with eah node having assigned a weight sore val(v): we want to ompute the funtion res(v) = f(u, v) for eah v V with (u, v) E, i.e. funtion f() is applied to node v and its predeessor u. For PSF, the funtion f() is defined as f(u, v) = val(u) + val(v) 2. To ompute the PSF for eah node of a list, the following algorithm is applied (we assume the nodes of the original list are sorted by the IDs (e.g. addresses) of the nodes): 1. Create a opy of the linked list and sort it by the ID (e.g. address) of eah node s suessor. (I/O omplexity: O(sort(N))). 2. San both lists, the original and the opied list, simultaneously and ompute f(u, v) for eah node v (I/O omplexity: O(san(N))). Figure 3 shows the original linked list from figure 2 and its sorted opy. The links between the nodes of boths lists are omitted for larity. Using this algorithm, it is obvious from the figure that the node and its predeessor are immediately available during simultaneous, linear san of both lists. The total I/O omplexity of this algorithm is: O(san(N)) + O(sort(N)) = O(sort(N)) 1 It an be shown that the lower bound of the list ranking problem is Ω(sort(N)). 2 The first node of the linked-list requires speial handling, but this orner ase is omitted for simpliity.

3 Algorithms for External Memory 3 Figure 3: I/O-Effiient Computation of Pairwise-Sum-Funtion (PSF) 2.2 Computing Independent Set of Graph An independent set I in a graph G = (V, E) is a set of nodes v V suh that if v I, then w / I if (v, w) E or (w, v) E, i.e. the independent set only ontains non-neighboring nodes. We will show that we may ompute an independent set of a linked list of size N 3 with O(sort(N)) I/O operations by reduing this problem to the problem of 3-oloring a linked list. One a 3-oloring of the linked list is found, the nodes having the olor with highest quantity represent an independent set. More formally: k-oloring of a graph is defined as oloring the nodes of a graph with k distint olors suh that no two neighboring nodes are olored with the same olor. Note, a linked list may generally be olored with two distint olors by alternating the olors for eah node, however this requires O(N) I/O omplexity due to omplete list traversal. For the purpose of illustrating the single steps of the algorithm, we will use the linked list in figure 4 as a base example. Figure 4: Example: 3-oloring of Linked List Coloring of Linked List The first step in determining the 3-oloring of the linked list is to ompute ontiguous forward and bakward lists of the original linked list. A ontiguous forward list is defined as a set of neighboring nodes with inreasing memory address, e.g. the nodes a--f and d-g-h in figure 4 are examples for two forward lists. Contiguous bakward lists are defined likewise with dereasing memory address as exemplified with nodes h-e-b and f-d in figure 4. The funtion to proess the forward lists is shown in algorithm 1. It iterates over the elements of the linked list by inreasing memory addresses, i.e. it does not follow the next of eah visited node, and builds up multiple forward lists eah olored with alternating olors red and blue the first node of eah forward list is olored red. A priority queue (PQ) - prioritized by the address of the nodes - is used to manage multiple forward lists

4 Algorithms for External Memory 4 simultaneously, e.g. the forward list d-g-h is started before the forward list a--f is finished. The funtion to proess the bakward lists (algorithm 2) works likewise. The main differenes are that nodes are proessed by dereasing memory addresses and the nodes of eah bakward list are olored with alternating olors green and blue the first node of eah forward list is olored green. The funtion opposite() referened in both algorithms returns the opposite olor of the input argument, e.g. blue for the input argument red in the ase of forward lists. Algorithm 1 Find Forward Lists in Linked List 1: funtion proess forward list(l : linked list) 2: for eah v L in inreasing order of addresses do 3: if v.addr == PQ.minKey() then middle of list 4: x = PQ.deleteMin() 5: if v.nextptr == NULL then end element of L 6: olor v with x.olor 7: else if v.nextptr > v.addr then not last element of forward list 8: olor v with x.olor 9: PQ.insert(new objet(key = v.nextptr, olor = opposite(x.olor))) 10: end if 11: else if v.nextptr > v.addr then start of new forward list 12: olor(v, red ) 13: PQ.insert(new objet(key = v.nextptr, olor = blue )) 14: end if 15: end for 16: end funtion Algorithm 2 Find Bakward Lists in Linked List 1: funtion proess bakward list(l : linked list) 2: for eah v L in dereasing order of addresses do 3: if v.addr == PQ.maxKey() then middle of list 4: x = PQ.deleteMax() 5: if v.nextptr == NULL then end element of L 6: olor v with x.olor 7: else if v.nextptr < v.addr then not last element of forward list 8: olor v with x.olor 9: PQ.insert(new objet(key = v.nextptr, olor = opposite(x.olor))) 10: end if 11: else if v.nextptr < v.addr then start of new forward list 12: olor(v, green ) 13: PQ.insert(new objet(key = v.nextptr, olor = blue )) 14: end if 15: end for 16: end funtion Applying algorithms 1 and 2 to the linked list in figure 4 yields two forward lists and two bakward lists olored as shown in figure 5. As obviously visible in this figure, oloring onflits may our for some nodes in the forward and bakward list, as for example for node f that is olored red in the forward

5 Algorithms for External Memory 5 Figure 5: Example: 3-oloring of Linked List - Forward and Bakward Lists list and green in the bakward list. Note that these onflits only our for start or ending nodes of forward/bakward lists, beause an inner node annot be part of both lists, a forward and a bakward list, otherwise the in- and out-diretions would point into different diretions. To resolve the oloring onflits, the ending node in onflit is olored like starting node in onflit, e.g. the node h in the seond forward list is olored green instead of red. Sine only the olors of ending nodes of forward/bakward lists are swapped, the graph oloring property as defined above is not violated 3. I/O omplexity analysis The algorithm uses a priority queue (PQ) whereof eah operation, i.e. query, insertion and deletion, takes O( 1 log N B M ) I/O operations. The forward and bakward algorithms eah B B iterate over all nodes in the linked list, and perform at most 3 priority queue operations for eah node. So the total I/O omplexity of eah algorithm is: 3 N O( 1 B log M B N B ) = O(sort(N)) 2.3 Weighted List Ranking Algorithm To solve the weighted list ranking problem, we apply the following reursive algorithm to ahieve storing the umulative per-node sores within the nodes rather than in arbitrary memory regions inreasing the I/O omplexity of the omputation. 1. Find independent set I of size N with predefined onstant. (I/O omplexity: O(sort(N)), see setion 2.2) 2. Compute pairwise sum funtion (PSF) on non-members of I. (I/O omplexity: O(sort(N)), see setion 2.1) 3. Bridge-out v I. (I/O omplexity: O(sort(N))) 4 4. Reursively solve weighted list ranking on the new list. 5. Bridge-in v I. (I/O omplexity: O(sort(N))) 6. Compute PSF on v I. (I/O omplexity: O(sort(N))) Figure 6 illustrates the working priniple of the above algorithm with = 2. The numbered irles on the left side indiate the step number of the algorithm with step 0 representing the original linked list. 3 For an informal proof, validate the graph oloring property for different ases, e.g. forward/bakward lists with even/odd lengths. 4 The bridge out operation may be redued to the omplexity of PSF omputation due to hanging next pointers in respetive nodes.

6 Algorithms for External Memory 6 Figure 6: Example for I/O-Effiient List Ranking Algorithm Analysis of I/O omplexity If the independent set at eah reursive stage is of size at least N/ for some onstant 2, then the reursive all is performed on a list of size at most N N = N 1. Then the I/O omplexity is omputed as: { Q(N ( 1 )) + O(sort(N)) if N > M Q(N) = O( N ) if N < M B = ( ) N i log 2 B 1 i=0 O(sort(N)) Sine 2, 1 < 1 and we an apply the alulus for geometri series to the summation, resulting in the final I/O omplexity of: Q(N) = O(sort(N)) In Setion 2.2 we showed how to find an independent set of size at least N/3, i.e. in our ase = Appliations of the Weighted List Ranking Algorithm The appliations of weighted list ranking were mostly overed in the leture 7, but we will disuss them here for the sake of ompleteness of this leture. All appliations shown here are onsidered in the ontext of analyzing or omputing tree properties. As a prerequisite for this, we firstly need to transform the tree suh that eah undireted edge is represented by two direted edges, one going down and the other going up, as shown in figure 7. Visibly, onneting the down-going and up-going edges yields a linked list with the nodes of the tree ourring multiple times. To effetively onnet all the down-going and upgoing edges in memory for purpose of running through the nodes in a single run, we onstrut the Euler Tour of a tree. The Euler Tour of a graph is a yle through the graph suh that eah node/edge is visited one. Considering a single node in the tree,

7 Algorithms for External Memory 7 Figure 7: Transformation of Tree as in figure 8, we may ompute the Euler Tour by reating edges (i j, o j+1 mod k) where k is the number of hild nodes plus the urrent node, i.e. k = 3 in our example. For orretness of this speifiation, x mod 1 := 0. The I/O omplexity for onstruting the Euler Tour is O(sort(N)) due to sorting the indies of edges. Figure 8: Constrution Priniple of Euler Tour In the following paragraphs, we will introdue three examples for weighted list ranking appliations. While the Euler Tour is important for finding a path for visiting the nodes, we will stik to the graphial representation shown figure 7 for larity Rooting a tree: Parent/Child Relationships for Un-Rooted Trees An un-rooted tree is a tree without an expliitly marked root node. An example of an un-rooted tree is shown in figure 9. Figure 9: Example for an Un-Rooted Tree

8 Algorithms for External Memory 8 As an example, assume that node r is seleted as root node. Applying the weighted list ranking (of the Euler Tour) with eah down-going and up-going edge weighted with 1, yields the graph in figure 10. Figure 10: Example for an Un-Rooted Tree Finally, an arbitrary node x is parent of its neighboring node z, if and only if, wlr sore((x, z)) < wlr sore((z, x)) Finding the Depth of Eah Node in a Rooted Tree Finding the depth, i.e. distane from the root, of eah node in the tree, the edges in figure 7 are weighted with 1 for down-going edges and -1 for up-going edges. Afterwards, the weighted list ranking algorithm is applied for eah node (of the Euler Tour) Computing the Size of Sub-Trees To ompute the size of a sub-tree, the edges in figure 7 are weighted with 1 for downgoing edges and 0 for up-going edges. Afterwards, the weighted list ranking algorithm is applied for eah edge (of the Euler Tour). Finally, the size of a sub-tree rooted at node x is omputed by wlr sore((x, parent(x))) wlr sore((parent(x), x)) + 1.