SESSION GRAPH BASED AND TREE METHODS + RELATED ...

More documents

Recommendations

Info

30 Int'l Conf. Foundations of Computer Science | FCS'12 | is in the NP category, it has no polynomial time solution, until it will be proved that P = NP. For solving STP on the graph, there are some exact approaches that one of them is Hakimi’s algorithm with time complexity of O(� � 2 � ) [4]. This algorithm for any subset � of � − 2 terminals or less finds the Minimum Spanning Tree (MST) of � ∪ � and then it selects the minimum result as Steiner tree. The other famous exact algorithm for finding Steiner tree on the graph is Dreyfus and Wagner’s algorithm that has O(�3 � + � � 2 � + � � ) time complexity and it has used dynamic programming [1]. Because of low-speed of exact approaches, they are not practically useful, therefore a lot of heuristic algorithms have been suggested for solving this problem. Those heuristic algorithms that have higher speeds and lower error percentages are better used. Some of these approaches are as follows: MST based algorithms like algorithms of Takahashi et al. [5] and Wong et al. [6] that for finding Steiner tree, they add an edge at each time until all terminals connect together; Node-based local search algorithms like Dolagh et al. [7] that find Steiner tree with using local search and identifying proper neighbors; Greedy Randomized Search algorithms [8] that have three phases: a construction phase, a local search phase and if necessary an updating phase. In each iteration of construction phase, a probable answer is created by selecting an element from a sorted list of candidate elements. This list is sorted based on greedy function, but the first element of the list is not always the best one, hence at the end of construction phase a local search is used for improving the answer and if necessary an updating phase is applied. There are also a lot of Meta heuristic algorithms for finding Steiner tree, like Ant colony approach [9, 10] and PSO [11]. Furthermore still the researches are done for finding algorithms for solving STP in better rates and shorter times. 3 The Proposed Algorithm The algorithm that is suggested in this article that called MSTG, finds Steiner tree on an undirected and weighted graph � = (�, �, �) . In this graph � is the number of vertices in �, � is the number of edges in � and � is the number of terminal nodes in �. The set � that is defined as � = �\� , contains Steiner nodes. The inputs of this algorithm are the graph � and the set � and also there is an assumption that says there is no isolated terminal in � .This means that from each terminal, there are some edges to the other terminals. This algorithm consists of three phases: the preprocessing phase, the first phase and the second phase. Finally, the outputs of this algorithm are the Steiner tree and its cost. 3.1 Preprocessing Phase The goal of this phase is the reduction of the counts of nodes and edges in the given graph. The Steiner nodes that have less than two edges (Deg < 2) and their connected edges are those ones that aren’t necessary in Steiner tree computation; therefore, in this phase, they are omitted. The resulted graph of this phase is called �’ and the related pseudo code is Fig. 1. Algorithm MSTG// Preprocessing Phase Input: �, � = (�, �, �) Output: �’ = (�’, �’, �) // � = �\� 1 for each � � ∈ � do 2 if Deg(� �) < 2 then 3 Remove � � from � and its edge from �; 4 end if 5 end for Fig.1: Pseudo code of Preprocessing Phase 3.2 First Phase In this phase of the algorithm, the shortest path between each terminal to one of the other terminals, which is the closest, is computed. The inputs of this phase are graph �’ and the set � and the outputs are the set of edges (�) and the set of nodes (�) from the obtained paths. Fig. 2 is the pseudo code of this phase. Definition: “ShrtTree (�, �)” is a procedure that its output is a set of shortest paths from node � to each node in the set � . These paths are obtained by computing the shortest tree that rooted in � and its leaves are the nodes in the set �. This procedure uses Dijkstra’s algorithm. The first loop (lines 1-5) of this pseudo code is executed for each terminal (� �), and it obtains a shortest path tree from � � to other terminals by using Dijkstra’s algorithm. Afterward, among all these paths in the tree, the shortest path from � � to another terminal is selected and added to the i th cell in the array �. Then its edges are added to �, and its nodes are added to �. The second loop (lines 6-20) is repeated for � times or until no changes occur in the �. This loop is exactly like the previous loop, but it obtains a shortest path tree from � � to other nodes in �. If the weight of this shortest path is less than the weight of the previous path for � � in � and it has no repeated edge with the previous path, then its edges and nodes are exchanged with the previous ones in � and �. The number of the variable � , according to the experimental results has been determined three, and it’s sufficient. At the
Int'l Conf. Foundations of Computer Science | FCS'12 | 31 end of this phase there is an omission of repeated nodes in � and repeated edges in � (lines 21, 22). Algorithm MSTG// First Phase Input: �, �’ = (�’, �’, �) Output: �, � Initialization: � = φ, � = φ, � = φ, � =3. //P is a set of edges; N is a set of nodes; � is an array of size r; //J is a counter. 1 for each � � ∈ � do 2 � � ← Min{ShrtTree(� �, �)}; 3 � ← � + � �.edges; 4 � ← � + � �.nodes; 5 end for 6 repeat 7 flag ← true; 8 �←�-1; 9 for each � � ∈ � do 10 Temp ← Min{ShrtTree(� �, �)}; 11 if Temp < � � and Temp.edges ≠� �.edges then 12 � ← �\� �.edges; 13 � ← �\� �.nodes; 14 � � ← Temp; 15 � ← � + � �.edges; 16 � ← � + � �.nodes; 17 flag ← false; 18 end if 19 end for 20 until flag=true or �=0. 21 Remove all repeated edges in �; 22 Remove all repeated nodes in �; Fig.2: Pseudo code of First Phase 3.3 Second Phase In this phase after examination of the connectivity status of the terminals, if there are any isolated trees they should be connected. For this reason, all the edges in � that connected together are put in the same groups. Afterward if the number of groups be greater than one, three loops are executed. Fig. 3 is the pseudo code of this phase. In the first loop (lines 3-6), the shortest paths from each node in � to other nodes of it that they are not in the same groups, are computed. Afterward, the resulted paths will be added to �. In the second loop (lines 7-15), until all the separated trees are not joined together, a path with lowest-cost that connects two trees is selected from the �. The edges and nodes of the selected path are respectively added to � and � and also if there is any Steiner node in this path, it is added to set � . In this situation, the connectivity status of the groups and the number of isolated groups are updated. Algorithm MSTG// Second Phase Input: �, �’ = (�’, �’, �), �, � Output: Steiner tree path, Steiner tree Cost Initialization: � = φ , � = φ. //C is a set of founded paths; H is a set of selected Steiner //nodes. 1 Put all � �� ∈ � which are connected together, in the same groups; 2 if groups number > 1 then 3 for each � � ∈ � do 4 �� ←all nodes in � with different groups from � � 5 � ← � + ShrtTree(� �, ��); 6 end for 7 while groups number> 1 do 8 Temp← Min{�} which is not added yet; 9 if Temp connects two groups then 10 � ← � + Temp.edges; 11 � ← � + Temp.nodes; 12 � ← � + Temp.Steiner nodes; 13 Update groups number; 14 end if 15 end while 16 for each ℎ � ∈ � do 17 if ℎ � has a shorter path to any � � ∈ � then 18 if this shorter path has the conditions then 19 Replace it with the previous one and update �and �; 20 end if 21 end if 22 end for 23 Delete all repeated edges in �; 24 Delete all repeated nodes in �; 25 end if 26 for each � � ∈ � do 27 if Deg(� �) < 2 then 28 Remove � � from � and its edge from �; 29 end if 30 end for 31 Compute the summation of costs of all � �� ∈ �. Fig.3: Pseudo code of Second Phase In the third loop (lines 16-22), if there are any Steiner nodes in the set �, for each of them, the shortest path is computed. If this path has lower cost than the previous one, and also it has the connection conditions, it is replaced with the previous path and the related edges and nodes in � and � are exchanged. In this algorithm, the path that has the connection condition doesn’t make a cycle or it doesn’t make terminals to be isolated.
Page 1 and 2: Int'l Conf. Foundations of Computer
Page 29: Int'l Conf. Foundations of Computer
Page 81 and 82:
Int'l Conf. Foundations of Computer
Page 83 and 84:
Page 85 and 86:
Page 87 and 88:
Page 89 and 90:
Page 91 and 92:
Page 93 and 94:
Page 95 and 96:
Page 97 and 98:
Page 99 and 100:
Page 101 and 102:
Page 103 and 104:
Page 105 and 106:
Page 107 and 108:
Page 109 and 110:
Page 111 and 112:
Page 113 and 114:
Page 115 and 116:
Page 117 and 118:
Page 119 and 120:
Page 121 and 122:
Page 123 and 124:
Page 125 and 126:
Page 127 and 128:
Page 129 and 130:
Page 131 and 132:
Page 133 and 134:
Page 135 and 136:
Page 137 and 138:
Page 139 and 140:
Page 141 and 142:
Page 143 and 144:
Page 145 and 146:
Page 147 and 148:
Page 149 and 150:
Page 151 and 152:
Page 153 and 154:
Page 155 and 156:
Page 157 and 158:
Page 159 and 160:
Page 161 and 162:
Page 163 and 164:
Page 165 and 166:
Page 167 and 168:
Page 169 and 170:
Page 171 and 172:
Page 173 and 174:
Page 175 and 176:
Page 177 and 178:
Page 179 and 180:
Page 181 and 182:
Page 183 and 184:
Page 185 and 186:
Page 187 and 188:
Page 189 and 190:
Page 191 and 192:
Page 193 and 194:
Page 195 and 196:
Page 197 and 198:
Page 199 and 200:
Page 201 and 202:
Page 203 and 204:
Page 205 and 206:
Page 207 and 208:
Page 209 and 210:
Page 211 and 212:
Page 213 and 214:
show all

SESSION GRAPH BASED AND TREE METHODS + RELATED ...

Create successful ePaper yourself

Delete template?

Save as template?