A branch-and-price algorithm for the Steiner tree packing problem

Computers & Operations Research 29 (2002) 221}241 A branch-and-price algorithm for the Steiner tree packing problem Gue-woong Jeong , Kyungsik Lee
, Sungsoo Park *, Kyungchul Park Department of Industrial Engineering, Korea Advanced Institute of Science and Technology, 373-1 Gusong-dong, Yusong-gu, Taejon 305-701, South Korea
Electronics and Telecommunications Research Institute, 161 Kajong-dong, Yusong-gu, Taejon 303-350, South Korea Telecommunication Network Lab., Korea Telecom, 463-1 Junmin-dong, Yusong-gu, Taejon 305-390, South Korea Received 1 February 1999; received in revised form 1 January 2000 Abstract This paper deals with the Steiner tree packing problem. For a given undirected graph G"(<, E) with positive integer capacities and non-negative weights on its edges, and a list of node sets (nets), the problem is to "nd a connection of nets which satis"es the edge capacity limits and minimizes the total weights. We focus on the switchbox routing problem in knock-knee model and formulate this problem as an integer programming using Steiner tree variables. We develop a branch-and-price algorithm. The algorithm is applied on some standard test instances and we compare the performances with the results using cutting-plane approach. Computational results show that our algorithm is competitive to the cutting plane algorithm presented by GroK tschel et al. and can be used to solve practically sized problems. Scope and purpose VLSI circuits becomes more complex with the need of miniaturization and sophisticated functions of electronic device. That makes designing a VLSI more di$cult. Due to these di$culties, it is common way to decompose it into several sub-problems. One of the sub-problems is the detailed routing problem, where exact path of wires is determined while minimizing some objective (for examples, total wire length) under some design rules. Among many kinds of detailed routing problem, we focus on the switchbox routing problem in knock-knee routing model. For this problem, we developed an integer programming model and solved it successfully for some test problems.  2001 Elsevier Science Ltd. All rights reserved. Keywords: Steiner tree packing problem (STP); VLSI design; Branch-and-price; Column generation * Corresponding author. Tel.: #82-42-869-3121; fax: #82-42-869-3110. E-mail address: [email protected] (S. Park). 0305-0548/01/$ - see front matter  2001 Elsevier Science Ltd. All rights reserved. PII: S 0 3 0 5 - 0 5 4 8 ( 0 0 ) 0 0 0 6 6 - 6 222 G.-w. Jeong et al. / Computers & Operations Research 29 (2002) 221}241 1. Introduction Very large-scale integration (VLSI) refers to a technology through which it is possible to implement large circuits in silicon. The VLSI technology has been successfully used to build microprocessors, signal processors, large capacity memories, memory controllers and interconnection networks [1]. Since a VLSI circuit is usually composed of numerous transistors, designing a VLSI circuit is a very complex and di$cult task. To overcome the di$culties, a VLSI circuit is usually designed through two phases, i.e. logical design and physical design. In the logical design phase, it is speci"ed which logical units (called cells) will be used and it is determined which of the speci"ed logical units should be connected by wires [2]. A cell has contact points, called terminals, through which cells are connected by wire. A set of terminals, which must be connected, is called a net. The list of cells and the list of nets are determined in the logical design phase and provided as an input to the physical design phase. In the physical design phase, it is determined where the cells are located in silicon and how the nets are connected while minimizing an objective function under some design rules. Most physical design problems are NP-hard and moreover, in the real world application, there are so many cells and nets that we cannot solve it to optimality. Therefore, in order to reduce this involved complexity, the physical design problem is usually decomposed into several subproblems. First, we "nd the appropriate locations of cells (placement problem). Subsequently, we determine approximate course of wires to connect nets (global routing problem). After global routing, exact path of the wires is determined without changing the layout area (detailed routing). Finally, if needed, compaction is performed to reduce the layout area. The above process is repeated if the resulting solution is not acceptable. Here, we consider a problem arising in the detailed routing. The detailed routing problem is classi"ed according to two criteria (routing graph, routing model). In the routing graph, there are channel routing graph, switchbox routing graph, and general routing graph. In the routing model, there are planar routing model, knock-knee routing model, Manhattan routing model, multilayer model, etc. [3]. The detailed routing problem considered in this paper is the switchbox routing problem in the knock-knee routing model (SBKP). We give a brief explanation of the switchbox routing graph and knock-knee routing model. The switchbox routing graph is a complete rectangular grid graph and the terminal sets are located on the four sides of the grid [2]. An example of the switchbox routing model is shown in Fig. 1. The numbers on the four sides denote net number and terminals with the same net number must be connected. Since the size of the routing graph (layout area) is "xed, we have to optimize the total wire length. We may be able to reduce the layout area in the compaction process with the detailed routing solution. In the knock-knee routing model, we "nd an edge disjoint connection of nets. Note that since the routings of nets need not be node disjoint, knock-knees are allowed (see Fig. 2). Since wires can cross (knock-knee is possible), this model has high routability relative to the other routing models. But, the assignment of the routing to layers is not considered in this model. If knock-knee is allowed, then at least two layers are needed. Brady and Brown [4] have designed an algorithm that routes any solution in this model on four layers. Lipski [5] proved that the problem of deciding whether a knock-knee routing needs only three layers is NP-complete. For more detailed explanations of routing graphs and models, refer to Burstein [6], Lengauer [3] and Sait and Youssef [1]. Now, let us illustrate an example (see Fig. 3). The numbered nodes denote terminals and the nodes with the same number (called a net) should be connected. We must "nd the edge-disjoint G.-w. Jeong et al. / Computers & Operations Research 29 (2002) 221}241 223 Fig. 1. Switchbox routing graph [2]. Fig. 2. Knock-knee [2]. connection of nets. In Fig. 3, an example of the connection is shown as solid lines. Dotted lines denote the edges that are not used. Note that each edge can be used at the most once. Before de"ning our problem, we introduce a well-known terminology, Steiner tree in graph theory. Given an undirected graph G"(<, E) and a node set N-<, if an edge set S-E connects all nodes in N, we call this edge set S a Steiner tree for N. The Steiner tree packing (STP) was described by GroK tschel et al. [2] as follows. Given an undirected graph G"(<, E) with edge capacities c 3Z for all e3E and a list of node set N"
N ,2, N  with N -<, k"1,2, n, C >  L I "nd Steiner trees S for N , k"1,2, n such that each edge e3E is contained in atmost c of the I I C edge set S ,2, S . Every collection of Steiner trees S ,2, S with this property is called a Steiner  L  L tree packing. If weights of the edges are given in addition and (with respect to these weights) minimal Steiner tree packing must be found, we call this the weighted Steiner tree packing problem. Note that this description is more general than our problem (SBKP). Many detailed routing problems can be modeled as the Steiner tree packing problem. Especially, the switchbox routing 224 G.-w. Jeong et al. / Computers & Operations Research 29 (2002) 221}241 Fig. 3. Example of SBKP. problem in the knock-knee routing model can be modeled as the Steiner tree packing problem with the following additional restrictions. (i) The underlying graph G"(<, E) is a complete rectangular grid graph, (ii) The edge capacities c "1 for all e3E, C (iii) The edge weights w "1 for all e3E. C Considering that "nding a Steiner tree in a graph is NP-hard, it is not strange that STP is NP-hard (see, for example, Garey and Johnson [7], Karp [8] and Kramer and Leeuwen [9]). And even the switchbox routing in kncok-knee model (SBKP) is also NP-hard [10]. Due to the inherent di$culties to solve the detailed routing problem, many researchers have developed various heuristics, but the performance of these heuristics could not be evaluated exactly because the optimal solutions could not be found. However, GroK tschel et al. [2] developed a cutting plane algorithm based on polyhedral theory, which solved SBKP to near optimal. Their work gives not only a good algorithm, but also the criteria for evaluating quality of some heuristics. But, there is a disadvantage that it takes a lot of time to solve the problem. This fact motivates us to "nd a di!erent approach. So, we developed an integer programming model, which is appropriate for column generation. G.-w. Jeong et al. / Computers & Operations Research 29 (2002) 221}241 225 The rest of this paper is organized as follows. In Section 2, we give two mathematical formulations of the problem and explain the motivation of our approach. In Section 3, overview of our algorithm is described brie#y. In Section 4, we explain the column generation procedure in detail. In Section 5, two branching rules applied in the branch-and-bound procedure are presented. In Section 6, we give a detailed explanation of our primal-heuristic. In Section 7, we address more technical details in implementing our algorithm. In Section 8, we present computational results of our algorithm on the standard test problems. Section 9 concludes this paper. 2. Problem formulations In this section, we give two mathematical formulations and explain the motivation of our approach in view of the bounds provided by the LP relaxations. SBKP can be stated as follows. Instance: A graph G"(<, E) and a list of node sets (called nets) N"
N ,2, N   L Problem: Find edge sets S ,2, S -E such that  L (i) A subgraph G "(<(S ), S ) is a Steiner tree with set of terminals N -<, for all k"1,2, n, I I I I (ii) L S 
e)1, for all e3E, I I (iii) L S  is minimal, I I where <(S ) is the set of nodes that are incident to the edges in S . Based on the integer I I programming model suggested by GroK tschel et al. [11], consider the following formulation. SBKP1: L min xI C I CZ# s.t. xI *1 for all =L<, =N O, (<=)N O, k"1,2, n, (1) C I I CZB5 L xI )1 for all e3E, (2) C I xI 3
0, 1 for all e3E and k"1,2, n, (3) C where (=) denotes the set of edges with one end node in = and the other in <=. The decision variable xI is a 0}1 variable where xI "1 if and only if edge e is contained in the Steiner tree for net C C k. Constraints (1) are called the Steiner cut inequalities and originally proposed for the Steiner tree problem on graph. Constraints (2) mean that each edge e3E can be contained in at most one of the edge sets S ,2, S GroK tschel et al. [2] solved this problem using some cutting planes such as  L Steiner partition inequalities, alternating cycle inequalities, and critical cut inequalities. For more details, refer to GroK tschel et al. [11,2]. 226 G.-w. Jeong et al. / Computers & Operations Research 29 (2002) 221}241 Generally the Steiner tree problem is known to be NP-hard [7,8]. But, since in our problem a given graph G is planar and all terminals are on the outer face of G, the Steiner tree problem can be solved in polynomial time [23]. When all terminals are not on the outer face, the Steiner tree problem becomes NP-hard. However, if the number of terminals in each net is small, the NP-hard Steiner tree problem can be solved e$ciently, for example, by a dynamic programming method with complexity O(3Rv#2Rv log v#v), where t is the number of terminals in the net and v is the number of nodes in the graph [12]. This fact motivates us to use the column generation approach to solve SBKP with the following formulation. SBKP2: L S y min G G I GZ2I s.t. GZ2I L y "1 for all k"1,2, n, G (4) y )1 for all e3E, G (5) I GZ2 C y 3
0, 1 for all i3¹ and k"1,2, n, (6) G I where S is the set of edges contained in Steiner tree i, ¹ is the set of all Steiner trees for net k and G I ¹ (e) is the set of Steiner trees for net k containing edge e. Decision variable y is a 0}1 variable I G where y "1 if and only if Steiner tree i is chosen. Constraints (4) mean that only one Steiner tree G for each net must be chosen. Constraints (5) have the same meaning as constraints (2). The main drawback of this kind of formulation (SBKP2) is the number of variables involved. The number of variables for each net is in general exponential in the size of the input. But, the linear programming relaxation of this formulation (SBKP2) gives a tight lower bound. The linear programming relaxations of the formulations can be obtained by replacing constraints (3) and (6) with nonnegativity constraints, respectively. For convenience, we denote the LP relaxation of SBKP1 and that of SBKP2 by LSBKP1 and LSBKP2, respectively. Let S¹ and conv(S¹ ) be the set of binary I I vectors each of which represents a Steiner tree for net k and the convex hull of S¹ , respectively. I Consider the following linear program. LP1: L min xI C I CZ# s.t. (2) and xI3conv(S¹ ) for all k"1,2, n. I I Proposition 1. The LP relaxation of SBKP2 (LSBKP2) and LP1 have the same optimal value. Proof. Suppose that x "(x , x ,2, x L) is a feasible solution to LP1, where each x I is a Ecomponent vector for net k. Then each vector x I in x can be expressed as a convex combination of G.-w. Jeong et al. / Computers & Operations Research 29 (2002) 221}241 227 some extreme points of conv(S¹ ). That is, I KI M G qG for all k"1,2, n, x I" I I G where M G *0, KI M G "1, and q,2, qKI are extreme points of conv(S¹ ). Since q,2, qKI are I G I I I I I I extreme points of conv(S¹ ), each qG represents a Steiner tree for net k. Let y G be the variable in I I I LSBKP2 corresponding to the Steiner tree represented by qG . To obtain a feasible solution, we I simply assign the value M G to y G , i"1,2, m and k"1,2, n and set the others of y G 's to zero. I I I I Then the obtained solution is feasible to LSBKP2. Conversely, from a given feasible solution to LSBKP2 a feasible solution to LP1 can be obtained similarly. Hence LSBKP2 and LP1 have the same objective value. 䊐 Let Z , Z and Z denote the optimal objective value of LP1, LSBKP1, and LSBKP2, *. * * respectively. Since every feasible solution of LP1 is also a feasible solution to LSBKP1, Z )Z . Therefore, LSBKP2 gives a lower bound as tight as the one provided by LSBKP1 * *. since Z )Z "Z . In view of the bounds of the LP relaxations, SBKP2 is more attractive * * *. than SBKP1. 3. Overview of our algorithm In this section, we give a brief explanation of our algorithm to solve the switchbox routing problem in knock-knee routing model (SBKP). Since our formulation (SBKP2) has exponentially many variables (columns), we use a branch-and-price approach, which is a generalization of branch-and-bound with LP relaxations, allowing column generation to be applied throughout the branch-and-bound tree [13]. This approach has been applied successfully to solve many large-scale mixed integer programming problems (for instance, see Johnson et al. [14] and Savelsbergh [15]). In this approach, only part of the column is included in the LP relaxation in order to handle the LP relaxation e$ciently. Moreover, most of the other columns will be zero in an optimal solution. To check the optimality of an LP solution, a subproblem, called the column generation problem or the pricing problem is solved to "nd columns to enter the basis. The column generation problem is a separation problem for the dual LP. If such columns are found, the LP is reoptimized with a subset of those columns added. This process continues until no such columns are found. Then if the "nal solution is not integral, branching occurs. The column generation is performed similarly throughout the branch-and-bound tree. For a comprehensive survey of this approach, refer to Barnhart et al. [13]. The pure branch-and-price approach can be strengthened by simultaneously applying the cutting plane approach. For example, Park et al. [16] could solve the bandwidth packing problem very e$ciently by such an approach. We start our algorithm by reducing the problem size using critical cut that is de"ned in GroK tschel et al. [2]. In this step, for each net we identify the edges that cannot be used to remove the edges from the underlying graph. Next, we construct the initial linear program using solutions obtained by a heuristic given in the literature [17}19]. Then we solve the LP relaxation of SBKP2 (LSBKP2) to optimality at node 0 in the enumeration tree using the column generation method. 228 G.-w. Jeong et al. / Computers & Operations Research 29 (2002) 221}241 Fig. 4. Overview of our algorithm. The column generation method is for "nding the columns to enter the basis. If there exist columns to enter the basis, we add the columns found into the LP relaxation and reoptimize it. Whenever the LP relaxation, LSBKP2 is reoptimized after some columns are added, the primal-heuristic is performed to obtain a good feasible solution which provides an upper bound of the optimal solution of SBKP2. Otherwise, i.e., if there are no columns to enter the basis, the LP solution is optimal. If the optimal solution of LSBKP2 is integral or the primal-heuristic solution is equal to Ulpvalue V where lpvalue is the optimal value of LSBKP2, then stop * we obtain the optimal solution of SBKP2. Otherwise, we use branch-and-price procedure which is a generalization of branch-and-bound with LP relaxations, allowing column generation to be applied throughout the branch-and-bound tree. Best bound rule introduced in Nemhauser and Wolsey [20] is used for branching node selection. The overall procedure of the algorithm is presented in Fig. 4. In the following sections, we explain the details of the algorithm. G.-w. Jeong et al. / Computers & Operations Research 29 (2002) 221}241 229 4. Column generation procedure As stated in Section 3, only part of the columns (variables) is contained in the initial LP relaxation. The restricted LP relaxation of SBKP2 is denoted by LSBKP2 . To check the optimality of the solution of LSBKP2 , a column generation problem is solved to "nd columns to enter the basis. Suppose that we are given an LSBKP2 . Let , be the dual variable vector for constraints (4) and (5) in LSBKP2 , respectively. Then the optimality condition is )S  for all i3¹ and )0 for all e3E and k"1,2, n. (7)  # C G I C I G CZ1 The optimality condition (7) is equivalent to (1! )* , for all i3¹ and )0, for all CZ1G C I I C e3E and k"1,2, n. Hence, the column generation problem can be stated as follows. For all k"1,2, n, CGP: min (1! )z C C CZ# s.t. z3S#, I where S# denotes the set of 0}1 vectors each of which represents a Steiner tree for net k. The I column generation problem (CGP) is to "nd a minimal Steiner tree for each net k in the graph G with edge weight w "1! , for all e3E. If the value of a minimal Steiner tree for net k is less C C than  , the corresponding column can be entered into the basis. Otherwise, the current solution is I optimal with respect to net k. Many heuristics and some optimal algorithms for the Steiner tree problem have been developed. Some useful surveys of the Steiner problems are available in Hwang and Richards [21] and Winter [22]. Fortunately, there exist some optimal algorithms for the Steiner problem in planar graph. Dreyfus and Wagner [12] developed a dynamic programming algorithm with time complexity O(3Rv#2Rv log v#v). Note that it is an exponential time algorithm. Erickson et al. [23] improved this algorithm for the case that all terminals are on the outer face of a graph. The time complexity of the algorithm of Erickson et al. [23] is O(vt#(v log v)t). Note that it is a polynomial time algorithm. We use the above two algorithms to solve CGP. At node 0 in the branch-and-bound tree, since all terminals are on the outer face of a graph, we solve CGP by the algorithm of Erickson et al. [23] in polynomial time. But, when the optimal solution of LSBKP2 does not satisfy integrality, we apply branch-and-price procedure to obtain the integer optimal solution. The key to develop a branch-and-price procedure is identifying a branching rule that eliminates the current fractional solution without making the column generation problem intractable after branching. We have developed two branching rules. One of them, branching rule 1 is to separate the solution space into two subspaces which are obtained by forcing an edge e to be in the Steiner tree for net k or not. Suppose that we are in the branch in which edge e is used for net k and both the end nodes of the edge e are not on the outerface. Then the two end nodes are included in the set of terminal nodes. Then, since all terminals are not on the outer face of G, CGP becomes NP-hard. Hence, we cannot help applying the algorithm of Dreyfus and Wagner [12], which is an exponential time algorithm. The other rule, branching rule 2 is to separate the solution space into two subspaces only by specifying the nets that do not use an edge e3E. In this case, for the speci"ed nets, we simply delete 230 G.-w. Jeong et al. / Computers & Operations Research 29 (2002) 221}241 the corresponding edges in the graph. Then, we can solve CGP by the algorithm of Erickson et al. [23] in polynomial time since all terminals are still on the outerface of a graph. In the next section, detailed explanations for the branching rules are given. 5. Branching rules The conventional branching rule based on variable dichotomy is inappropriate to a branchand-price approach. Comprehensive explanation can be found in Savelsbergh [15]. For our problem a similar explanation as in Savelsbergh [15] is given as follows. Suppose that we branch on a fractional variable y and we solve the LSBKP2 in the branch where the variable y is "xed to G G zero. Then, it is possible (and quite likely) that the optimal solution of column generation problem will be the same Steiner tree represented by the variable y . In this case, we must "nd the Steiner G tree having the second lowest weight. In worst case, the depth k in the branch-and-bound tree, we have to "nd the Steiner tree having the kth lowest weight. Therefore, we need a branching rule that is compatible with the column generation problem. That is, we must be able to modify the column generation problem so that the columns that are infeasible to the branching constraints will not be generated [15]. As stated in the previous section, we have developed two branching rules. Branching rule 1 is very intuitive, but causes some changes in the column generation problem, which makes it more di$cult. Branching rule 2 does not cause any change, but is not as intuitive as branching rule 1. 5.1. Branching rule 1 Consider a binary variable xI . It denotes whether edge e is used for net k or not. The binary C variable xI can be expressed by binary variables y 's as follows: C G y for all e3E and k"1,2, n. (8) xI " G C GZ2I C It is clear that if xI is binary, then the corresponding y 's are also binary. Hence, we can use C G a branching rule with respect to the binary variables xI 's instead of one with the y variables. If xI is C C "xed to zero, we simply delete edge e from the graph when we generate a Steiner tree for net k not containing edge e. If xI is "xed to one, we must "nd a Steiner tree for net k which contains edge e. C To do this, we set the edge weight w to zero and declare the two end nodes of edge e as terminal C nodes. The following proposition guarantees that in case xI "1 the Steiner tree generated contains C edge e. Proposition 2. For a given graph G"(<, E), an acyclic edge set E "
(u, v)3E  w "0 and a node ST set N "
v3<  there exists a node u3(v) such that w "0, an optimal Steiner tree for a terminal ST node set N(MN ) must contain all the edges in E . Proof. Suppose that an optimal tree ¹H does not contain all the edge in E . Note that in the column generation problem every edge weight, w ("1! ) is positive except the edges in E since the C C dual variable, )0 for all e3E. We will prove using induction on E . C G.-w. Jeong et al. / Computers & Operations Research 29 (2002) 221}241 231 (i) For the case E "1, add the edge uv to ¹H. Then, there exists only one cycle in the new graph ¹H#uv and let the cycle be (uv, e , e ,2, e ). Remove an arbitrary edge e ,1)i)k from ¹H#uv.   I G Then, the resulting graph ¹ is also a Steiner tree for N. Let the total weight of a Steiner tree ¹ be  =(¹). Then, =(¹ )!=(¹H)"w !w G (0. This contradicts that ¹H is an optimal Steiner tree.  ST C (ii) Assume that for the case E )m, the optimal Steiner tree for N contains all the edges in E and consider the case when E "m#1. Let E be the set of edges that are in E but not in ¹H. For  each edge uv3E , add the edge uv to ¹H and set E "E 
uv. Then, there exists only one cycle in    the new graph ¹H#uv. Let the cycle be (uv, e , e ,2, e ). At least one of edges e , 1)i)k has   I G positive weight. Otherwise, all the edges in the cycle have zero weight. This implies that there exists an optimal Steiner tree not containing all the edges in E when E "k()m). Now, remove an edge having positive weight in the cycle. Repeat the above process until E ". Let E be the set of   removed edges. Then, the resulting graph ¹ is also a Steiner tree for N and it is clear  w ! w "! w (0. This contradicts that ¹H is an that =(¹ )!=(¹H)" CZ# C CZ# C  CZ# C optimal Steiner tree. 䊐 Branching rule 1 is easy to understand, but makes the column generation problem more di$cult. In case xI "0, we have no trouble in using the polynomial time algorithm of Erickson et al. [23]. C However, in case xI "1, since newly added terminal nodes may not be on the outerface of G, there C does not exist any polynomial time algorithm. Therefore, we cannot help using an exponential time algorithm of Dreyfus and Wagner [12]. But, the main drawback of the algorithm is that as the number of terminals increases, time required to generate a column increases exponentially. Therefore, it takes much time to generate a column when the number of branching with xI "1 C becomes large, i.e., many nodes are generated. But, we can expect that a few nodes may be generated because LSBKP2 may give a tight lower bound. Now, we present branching rule 1 in detail. For a given optimal solution yH to LSBKP2 , we "rst calculate xI for all e3E and k"1,2, n using Eq. (8). Then choose the most fractional (closest to C 0.5) variable xIHH among xI 's. From the current node in the branch-and-bound tree, we make two C C child nodes such that the "rst node represents the case where Steiner trees for net kH do not contain edge eH and the second node represents the case where Steiner trees for net kH contain edge eH. That is, for the "rst node, we require y "0 for all i3¹ H (eH) G I and for the second node, we require y "0 for all i3¹ H ¹ H (eH). I G I To satisfy the above requirements, for each Steiner tree variable y already generated, we set the G upper bound of the variable y to zero if i3¹ H (eH) in the "rst node. In the second node, we set the G I upper bound of the variable y to zero if i3¹ H ¹ H (eH). The column generation procedure is I G I performed as explained before. 5.2. Branching rule 2 For a given optimal solution yH to LSBKP2 , de"ne ;(yH, e) for all e3E as the set of nets for which at least one Steiner tree variable using edge e have a positive value, i.e. yH'0, i3¹ (e). G I 232 G.-w. Jeong et al. / Computers & Operations Research 29 (2002) 221}241 Clearly, if yH is integral, ;(yH, e))1 for all e3E. Although the converse is not true, we have the following positive result. Proposition 3. Suppose that an optimal solution yH to LSBK2 with the objective value ZH is given. If ;(yH, e))1 for all e3E, yH is either integral or there exists an integral feasible solution with the same objective value. Proof. Suppose that ;(yH, e))1 for all e3E, but yH is a fractional solution. Let ¹H be the set of I variables for net k having positive values, i.e., ¹H"
i3¹ : yH'0. I I G For each net k, k"1,2, n, if ¹H"1, there exists only one non-zero variable for net k. I Otherwise, we select any variable among the elements of ¹H and "x it to one and the others to zero. I Considering ;(yH, e))1, it is obvious that in the newly obtained solution two or more nets cannot contain the same edge (feasible solution). The variables in ¹H should have the same I objective coe$cient. Otherwise, this contradicts that yH is optimal solution. Hence, we can obtain an integral solution having the same objective value ZH. 䊐 By the above proposition, we have only to check if ;(yH, e))1 for all e3E instead of checking the integrality of the given optimal solution yH to LSBKP2 . Now, we explain branching rule 2 in detail. For a given optimal solution yH to LSBKP2 , we "nd eH3E such that eH"argmax ;(yH, e). If there are two or more edges having the same maximum CZ# cardinality of ;(yH, e), we choose the edge among them having the largest value of L xIH . In I C other words, we choose the edge used maximally by the Steiner trees. Let ;(yH, eH)"
k ,2, k .  K If ;(yH, eH)"1, we do not need to branch by Proposition 3. Otherwise, we divide ;(yH, eH) into two disjoint sets ; (yH, eH) and ; (yH, eH), such that ; (yH, eH)"
k ,2, k W X  and K     ; (yH, eH)";(yH, eH); (yH, eH). Then two child nodes are generated in the branch-and-bound   tree such that the Steiner trees for each net k3; (yH, eH) cannot use the edge eH in the "rst node  and those for each net k3; (yH, eH) cannot use the edge eH in the second node. That is, for the "rst  node, we require y "0 for all i3¹ (eH) G I and k3; (yH, eH)  and for the second node, we require y "0 for all i3¹ (eH) G I and k3; (yH, eH).  To satisfy the above requirements, for each Steiner tree variable y already generated, we "rst set G the upper bound of the variable to zero if i3¹ (eH) and k3; (yH, eH) in the "rst node. We perform I  similar bound setting in the second node. Then the current solution yH does not satisfy either of the conditions, hence excluded, and none of the feasible integer solutions in the current node are excluded from further consideration. Further, for each net k3; (yH, eH) we solve the column  generation problem in the graph obtained from deleting eH from the given graph G in the "rst node. For the second node, the same scheme is applied. Since the column generation problems can be solved by using the algorithm of Erickson et al. [23] over modi"ed graphs, they remain tractable after branching. G.-w. Jeong et al. / Computers & Operations Research 29 (2002) 221}241 233 6. Primal-heuristic In this section, we describe our primal-heuristic in detail. The primal-heuristic is developed to obtain a tight upper bound on the optimal solution. The rationale behind our primal-heuristic is that the information of the LP solution will be of great help in obtaining a good feasible solution. A large value of xI means that edge e is likely to be used for net k. This idea is exploited as follows. C For a given fractional solution y to LSBKP2, we calculate xI 's using Eq. (8). For a given graph C G"(<, E), assign weight w ("1!xI ) to edge e for all e3E. Then, to reduce the running time of C C the primal-heuristic we determine heuristically a Steiner tree for net k over the modi"ed graph instead of "nding the optimal Steiner tree. Our primal-heuristic consists of two phases. In the "rst phase, for a given fractional solution y , for each k, we "nd a variable having the largest value among the Steiner tree variables for net k}we denote it by y IH . If the value of y IH is greater than or equal to 0.9, we include the Steiner tree G G corresponding to the variable y IH in the primal-heuristic solution. Such Steiner trees cannot share G an edge, otherwise the fractional solution, y does not satisfy the capacity constraint for the shared edge. Hence, we can include the Steiner trees in the primal-heuristic solution without violating the feasibility. In the second phase, we consider the remaining nets. We sort the remaining nets in decreasing order of y IH 's and "nd heuristically Steiner trees for the remaining nets in the sorted G sequence. Details of the primal-heuristic are given as follows. (Initialization) Set S" and for k"1,2, n, set S ". I [Phase 1] The following steps are performed: Step 1: Sort the nets in decreasing order of y IH , where y IH "max I y . Let the ordered sequence be G G GZ2 G (1 ,2, n ) Step 2: Find the largest index p satisfying that y NYH *0.9. G Step 3: For k"1 ,2, p , set S "
edges of the Steiner tree corresponding to the variable y IH  I G and S"S S . I [Phase 2] For k"(p#1) ,2, n , the following steps are performed: Step 1: Set R "N and construct a new graph G "(<, E ) with edge weight w "1!xI for all I I I I C C e3E , where E "ES. I I Sh (s, t), where Sh (s, t) is the Step 2: If S ", determine sH, tH such that Sh (sH, tH)"min I I I I Q RZ,I value of the shortest path between the nodes s and t in G . I If Sh (sH, tH)"R, go to TERMINATION. I Else set S "S
edges in the sH!tHpath and R "R 
sH, tH. I I I I Else determine sH3R , tH3<(S ) such that I I Sh (s, t). Sh (sH, tH)"min I I QZ0 RZ41I  I If Sh (sH, tH)"R, go to TERMINATION. I Else set S "S
edges in the sH!tH path and R "R 
sH. I I I I Remove the edges in the sH}tH path from the graph G "(<, E ). I I If R O, repeat Step 2. I Else, set S"S S and go to Step 3. I 234 G.-w. Jeong et al. / Computers & Operations Research 29 (2002) 221}241 Step 3: If k"n , report a feasible solution S and STOP. Else, set k"(k#1) and go to Step 1. TERMINATION) Report `No feasible solution founda and STOP. In the second phase, we use a simple heuristic based on the shortest path algorithm to "nd a Steiner tree, although an optimal Steiner tree can be found in polynomial time. There are two major reasons. One is the possibility that the primal-heuristic fails to "nd a feasible solution. Due to this, we decided to perform the primal-heuristic as many times as possible, i.e., whenever the LP relaxation is reoptimized after some columns are added. Hence the primal-heuristic needs to be done in a short time. The other reason is that the primal-heuristic is only a heuristic. There is no guarantee that we can obtain a feasible solution when the optimal Steiner tree is found in the second phase. To our knowledge, a crucial point in obtaining a feasible solution in the primalheuristic lies in the sequence of the Steiner trees found, not in whether the optimal Steiner tree is found or not. If a feasible primal-heuristic solution is found and its value is less than the value of the current incumbent solution, then we add the Steiner tree variables in the primal-heuristic solution to the current LP relaxation and the current incumbent solution is updated. Of course, there is no guarantee that our primal-heuristic gives a good solution. However, we have obtained good upper bounds through our primal-heuristic for our test problems. 7. Implementation details 7.1. Initial solution To use the column generation procedure, we need to have some initial feasible columns in LSBKP2. We have applied our branch-and-price algorithm on some test problems, which are explained in Section 7. For these problems, there are heuristic solutions reported in the literature [17}19]. These heuristic solutions are used as the initial solutions. For some problems, the heuristics failed in obtaining a feasible solution. i.e., terminals in some nets were not connected (see Burstein and Pelavin [17] and Luk [19]). In this case, to obtain the feasibility of an initial LP, arti"cial variables for such nets are introduced as in the next section. The objective value of an initial feasible solution is used as an upper bound on the optimal solution in the branch-and-price procedure. 7.2. Artixcial variables To guarantee that an instance of LSBKP2 is always feasible regardless of which Steiner trees are added in the current LSBKP2 , arti"cial variables are introduced as follows. For each net, we introduce an arti"cial variable into the formulation with a su$ciently large objective coe$cient M, a coe$cient 1 in the corresponding row of constraints (4) and coe$cient 0 in all the other G.-w. Jeong et al. / Computers & Operations Research 29 (2002) 221}241 235 constraints. Then, constraints (4) become as follows. y #a "1 for all k"1,2, n. G I GZ2I We may start the column generation procedure with only arti"cial variables. But, this method may be inferior to the one starting with the columns of an initial solution in terms of the convergence speed. 7.3. Reducing problem size Using the critical cuts, GroK tschel et al. [2] have found the edges that cannot be contained in a Steiner tree for a net. By the same procedure in GroK tschel et al. [2], we can delete some edges from the underlying graph for each net. This implies that the number of possible Steiner trees for each net may be reduced. More detailed explanation and the algorithm to "nd the critical cut can be found in GroK tschel et al. [11,2]. 7.4. Removing unnecessary columns We need to remove unnecessary columns, if any, because too many columns cause some di$culties in solving linear programs. After solving LSBKP2 to optimality at node 0 in the enumeration tree, we can remove unnecessary columns using the following proposition. Proposition 4. Let Z and Z be an incumbent solution value to SBKP2 and the optimal solution ', *. value to LSBKP2, respectively. Let r denote the reduced cost of a variable y when LSBKP2 is solved to G G optimality at node 0. If y is nonbasic at lower bound in the optimal solution of LSBKP2 and G r 'Z !Z , then there exists an optimal solution to the integer program SBKP2 with y at its lower G ', *. G bound. Proof. Since y is a binary variable, y must be 0 or 1 in the optimal solution to SBKP2. Let G G ZH denote the optimal value of LSBKP2 when y is "xed to 1. Then, from the tableau of LSBKP2, G we can see that ZH*Z #r . This implies ZH'Z , since r 'Z !Z . Hence, there are no *. G ', G ', *. optimal solutions to SBKP2 with y "1 and it means that there exists an optimal solution to G SBKP2 with y "0. 䊐 G We can remove the columns satisfying the condition of Proposition 4 after solving LSBKP2 to optimality at node 0. In order to remove many columns, we need a good incumbent solution. This is one of the reasons why we need a primal-heuristic. 7.5. Solving the LP relaxation of SBKP2 When we solve the LP relaxation of SBKP2 by column generation, a primal simplex method is a natural choice for reoptimization than a dual simplex method since the added columns de"nitely 236 G.-w. Jeong et al. / Computers & Operations Research 29 (2002) 221}241 violate the dual feasibility, but the current basic solution still satis"es the primal feasibility. However, in our preliminary tests, dual simplex method seems to be more e$cient than primal to our problems. One major reason is that our problem is highly degenerate in the primal. The other formulation of SBKP introduced in Section 2 has similar di$culties in optimizing LP relaxation. The LP relaxation of SBKP1 (LSBKP1) is highly degenerate in both primal and dual [2]. To overcome such di$culties GroK tschel et al. [10] developed an elaborate perturbation method. But, in our case, the LP relaxation is highly degenerate only in primal. Therefore, we used the dual simplex method instead of perturbation method. Whenever optimizing a linear program using dual simplex method, we must solve it from the beginning again. So a dual feasible solution should be found in a short time. Fortunately, since objective coe$cients are all positive, we expect that CPLEX will not have any trouble in "nding dual feasible solutions within allowable time, even after adding the columns (CPLEX callable mixed integer library is used as an LP solver). In experimental results, it appeared that the dual simplex method is more appropriate than the primal to our problem. 8. Computational results We have solved the switchbox routing problems on which GroK tschel et al. [10] tested their cutting plane algorithm. These problems are standard examples in this area. The data of test problems are summarized in Table 1. In Table 1, column 1 presents the name used in the literature. The height and width of the underlying complete rectangular grid graph are given in columns 2 and 3, respectively. Column 4 presents the number of nets. Columns 5}9 describe the distribution of nets; more precisely, column 5 gives the number of two-terminal nets and column 6 gives the number of three-terminal nets and so on. The last column gives the reference to the paper the test problem is taken from. More detailed explanations of the test problems can be found in GroK tschel et al. [2]. Based on the distribution of nets, we can estimate approximately the relative di$culty of the test problem. The problem becomes more di$cult as the number of nets with many terminals increases. The dense Table 1 Data of test problems [2] Name Di$cult More di$cult Terminal intensive Dense Augmented dense Modi"ed dense Pedagogical H 15 15 16 17 18 17 16 B 23 22 23 15 16 16 15 N 24 24 24 19 19 19 22 Distribution of the nets Reference 2 3 4 5 6 15 15 8 3 3 3 14 3 3 7 11 11 11 4 4 5 5 5 5 5 4 1 0 4 0 0 0 0 1 1 0 0 0 0 0 [17] [18] [19] [19] [19] [18] [18] G.-w. Jeong et al. / Computers & Operations Research 29 (2002) 221}241 237 Table 2 E!ects of reducing the problem size (at node 0) Example Di$cult More di$cult Terminal intensive Dense Augmented dense Modi"ed dense Pedagogical Total edges 15648 14952 16728 9082 10298 9709 9878 Deleted edges Generated columns 2048 2176 4599 4593 2428 3789 1883 Without reducing With reducing 696 745 1637 5668 1997 3945 365 935 816 1836 3819 2382 3089 295 Table 3 Result of removing unnecessary columns (at node 0) Example Incumbent value LP value Unnecessary columns Di$cult More di$cult Terminal intensive Dense Augmented dense Modi"ed dense Pedagogical 464 452 538 None 469 452 336 464 452 535 438 467 452 331 689 (37.53%) 0 (0.00%) 613 (34.65%) 5 (1.70%) Means that we need not remove the unnecessary columns because an optimal solution in SBKP2 is obtained at node 0. problems (dense, augmented dense, modi"ed dense) seem to be more di$cult than the other test problems. At the beginning of our algorithm, we reduce the problem size by "nding critical cuts (see Section 6.3). The e!ects of reducing the problem size are reported in Table 2. In Table 2, columns 2 and 3 give the number of edges and the number of deleted edges in graphs for all nets. Columns 4 (5) states the number of generated variables without (with) reducing process when we solve LSBKP2 at node 0. We may expect that deleting some edges from the underlying graph reduces the number of generated variables. But, the numbers in Table 2 imply that this process has little positive e!ect on the number of generated variables (in some problems, more variables are generated). However, this reduces the number of possible choices in branching and the number of constraints in the linear program, hence we decided to apply this process. When LSBKP2 is solved to optimality at node 0, we can remove some unnecessary columns using Proposition 4 (see Section 5). The results are shown in Table 3. Columns 2 and 3 present the 238 G.-w. Jeong et al. / Computers & Operations Research 29 (2002) 221}241 Table 4 Results of branch and price with branching rule 1 (HP 9000 715/50) Example Best solution LP value Gap (%) Iterations Total columns Nodes CPU-time (m:s) Di$cult More di$cult Terminal intensive Dense Augmented dense Modi"ed dense Pedagogical 464 452 536 441 469 452 331 464 452 535 438 467 452 331 0.0 0.0 0.19 0.68 0.43 0.0 0.0 68 58 616 841 1435 201 37 935 816 4336 10,000 10,000 3089 318 1 1 32 10 35 1 2 32:26 25:20 853:00 1296:58 1661:55 131:49 6:44 Means that we solved the problem until the number of generated columns is less than or equal to 10,000. Table 5 Results of branch and price with branching rule 2 (HP 9000 715/50) Example Best solution LP value Gap (%) Iterations Total columns Nodes CPU-time (m:s) Terminal intensive Dense Augmented dense Pedagogical 536 441 469 331 535 438 467 331 0.19 0.68 0.43 0.0 241 1042 1730 124 2324 10,000 10,000 493 15 10 70 54 222:35 1604:01 1670:25 22:37 Means that we solved the problem until the number of generated columns is less than or equal to 10,000. value of the best feasible solution among the primal-heuristic solution and initial solution and that of optimal solution to LSBKP2, respectively. For dense problem, the initial solution is infeasible and we could not "nd any primal-heuristic solution at node 0. The last column shows the number of removed columns and the proportion of unnecessary columns to the generated columns in percentage terms. If the number in column 3 is close to that in column 2, i.e., a good feasible solution is obtained, then many unnecessary columns can be removed and this enables us to handle the LP relaxation more e$ciently. We observed this phenomena in some of test problems (Terminal intensive, Augmented dense). The results we have obtained with our branch-and-price algorithm are shown in Tables 4 and 5. We have applied two branching rules given in Section 4. Tables 4 and 5 present the results with branching rules 1 and 2, respectively. Table 6 presents the results GroK tschel et al. [2] obtained with the branch-and-cut algorithm on the same problems, which we include here for comparison. In Table 5, those problems for which an integer optimal solution is found at node 0 are not presented. Best solution means the value of the best feasible solution. LP value denotes the objective function value of the linear program at node 0. We can obtain the lower bounds on problems by rounding up these values. Gap is the percentage deviation of the best solution from the lower bound. This value is calculated as the following: gap"(best solution value!U LP value V )/U LP value V . In G.-w. Jeong et al. / Computers & Operations Research 29 (2002) 221}241 239 Table 6 Results of branch and cut by GroK tschel et al. [2] (SUN 4/50) Example Best solution LP value Gap (%) Iterations Total variables Nodes CPU-time (m:s) Di$cult More di$cult Terminal intensive Dense Augmented dense Modi"ed dense Pedagogical 464 452 537 441 469 452 331 464 452 536 438 467 452 331 0.0 0.0 0.19 0.68 0.43 0.0 0.0 69 53 163 119 105 51 77 13424 12502 11815 4251 7620 5652 7839 3 1 13 4 1 1 5 1564:15 983:23 3755:44 1017:43 4561:41 387:03 251:58 For the problems, no optimal solution is obtained. Tables 4 and 5, columns 5 and 6 give the number of column generation iterations and the number of generated columns, respectively. In Table 6, columns 5 and 6 give the number of cutting plane iterations and the number of total variables, respectively. In Tables 4}6, column 7 presents the number of nodes solved in the branch-and-bound tree. Finally, the last columns of all tables report on running times in minutes. LSBKP2 gives a very tight lower bound as we expected in Section 2 (the largest gap is 0.68%, see Tables 4 and 5). These lower bounds are the same as GroK tschel et al. [2] except for terminal intensive problem. In terminal intensive problem, the branch-and-cut algorithm of GroK tschel et al. [2] gives tighter lower bound. The cutting planes used by GroK tschel et al. [2] are Steiner partition inequality, alternating cycle inequality and critical cut. The Steiner partition inequality is a cutting plane for the convex hull of a Steiner tree and since the associated separation problem is NP-hard, GroK tschel et al. [2] solved it heuristically. The alternating cycle inequality is a cutting plane for the convex hull of Steiner tree packing with two nets and the associated separation problem was solved heuristically due to involved di$culty. The critical cut is used to "x some variables to zero as stated in Section 6.3. Now, consider two facts; one is that LSBKP2 describes fully the convex hull of a Steiner tree. The other is that our algorithm gives the same lower bounds as GroK tschel et al. [2] except for terminal intensive problem. Based on these observations, we may give some remarks regarding the strength of the cutting planes used in GroK tschel et al. [2] in view of lower bound. First, the cutting planes (Steiner partition inequalities, alternating cycle inequalities, and critical cuts) do much for achieving a good lower bound since the convex hull of a Steiner tree can not be described fully by only the Steiner cut inequality. Second, if the Steiner partition inequality describes well the convex hull of a Steiner tree although its separation problem is not solved optimally, the alternating cycle inequality does not make a large contribution to the lower bound. Otherwise, it may compensate for de"ciency of Steiner partition inequality. For all problems, we obtained the same best solution value as GroK tschel et al. [2] did. Especially, for terminal intensive problem, we obtained the optimal solution with value 536, while GroK tschel et al. [2] stated that the optimal value is 537. We discussed this result with Martin [11,2] and he solved the problem once more to get the same optimal value. For dense and augmented dense problem, we failed to obtain the optimal solution because, due to the limit of memory, we set the 240 G.-w. Jeong et al. / Computers & Operations Research 29 (2002) 221}241 maximum number of columns included in the linear program to 10,000. GroK tschel et al. [2] could not obtain optimal solutions for these problems, either. We solved the test problems on a HP 9000 715/50 and GroK tschel et al. [2] solved them on a SUN 4/50. The information of these two machines is as follows; The CPU clock, million instructions per second (MIPS) and million #oating point operations per second (MFLOPS) of HP 9000 715/50 are 50 MHz, 62 and 13, respectively. The CPU clock, MIPS and FLOPS of SUN 4/50 are 40 MHz, 28.5 and 4.2. With only this information, it is unreasonable for us to give some statements for the speeds of two machines. However, even assuming that HP 9000 715/50 is three times faster than SUN 4/50, our algorithm is competitive to GroK tschel et al. [2] in running time for all problems except dense and augmented dense problem for which they could not "nd optimal solutions either. Now, we discuss the results of branching rules 1 and 2. With the results in Tables 4 and 5, we cannot determine which branching rule is better. Dense and augmented problems are di$cult to solve irrespective of the branching rule applied. For the terminal intensive problem, branching rule 2 is better than branching rule 1. But, branching rule 1 is better than branching rule 2 for the pedagogical problem. As stated in Sections 4 and 5, depending on the branching rule applied, the time complexity of column generation problem is di!erent. The column generation problem can be solved in polynomial time with branching rule 2 but not with branching rule 1. However, the e!ect of di!erent time complexities did not appear apparently in our results. 9. Conclusion In this paper, we proposed an algorithm based on column generation procedure to solve the Steiner tree packing problem. We explained how the LP relaxation of the problem, which has exponentially many variables, is solved by column generation procedure. We also developed branching rules which make the column generation problem tractable after branching. Computational results show that the algorithm solved test problems more e$ciently than GroK tschel et al. [2] even though our formulation has exponentially many variables. We can expect that our algorithm can be used to solve practically sized problems. As stated earlier, there are many possible models for routing problem in VLSI design since the routing problem can be de"ned by combining two criteria. Our model is for only one of these possible models. The other models can be very interesting topics for further research. References [1] Sait M, Youssef H. VLSI physical design automation. London: McGraw-Hill, 1995. [2] GroK tschel M, Martin A, Weismantel R. Packing Steiner trees: a cutting plane algorithm and computational results. Mathematical Programming 1996;72:125}45. [3] Lengauer T. Combinatorial algorithms for integrated circuit layout. New York: Wiley, 1990. [4] Brady ML, Brown DJ. VLSI routing: four layers su$ce. In: Preparata FP, editor. Advances in computing research, vol. 2: VLSI theory. London: JAI Press, 1984. p. 245}58. [5] Lipski W. On the structure of three-layer wireable layouts. In: Preparata FP, editor. Advances in computing research, vol. 2: VLSI theory. London: JAI Press, 1984. p. 231}44. [6] Burstein M. Channel routing. In: Ohtsuki T, editor. Advances in CAD for VLSI, vol. 4: layout design and veri"cation. Amsterdam: North-Holland, 1986. p. 133}67. G.-w. Jeong et al. / Computers & Operations Research 29 (2002) 221}241 241 [7] Garey MR, Johnson DS. The rectilinear Steiner tree problem is NP-complete. SIAM Journal on Applied Mathematics 1972;32:826}34. [8] Karp RM. Reducibility among combinatorial problems. In: Miller RE, Thatcher JW, editors. Complexity of computer computations. New York: Plenum Press, 1972. p. 85}103. [9] Kramer MR, Leeuwen JV. The complexity of wire-routing and "nding minimum area layouts for arbitrary VLSI circuits. In: Preparata FP, editor. Advances in computing research, vol. 2: VLSI theory. London: JAI Press, 1984. p. 129}46. [10] Sarrafzadeh M. Channel-routing problem in the knock-knee mode is NP-complete. IEEE Transactions on Computer-Aided Design 1987;CAD-6:503}6. [11] GroK tschel M, Martin A, Weismantel R. Packing Steiner trees: polyhedral investigations. Mathematical Programming 1996;72:101}23. [12] Dreyfus SE, Wagner RA. The Steiner problem in graphs. Networks 1972;1:195}207. [13] Barnhart C, Johnson EL, Nemhauser GL, Savelsbergh MWP, Vance PH. Branch-and-price: column generation for solving huge integer programs. Operations Research 1998;46:316}27. [14] Johnson EL, Mehrotra A, Nemhauser GL. Min-cut clustering. Mathematical Programming 1993;62:133}52. [15] Savelsbergh MWP. A branch-and-price algorithm for the generalized assignment problem. Operations Research 1997;45:831}41. [16] Park KC, Kang SH, Park SS. An integer programming approach to the bandwidth packing problem. Management Science 1996;42:1277}91. [17] Burstein M, Pelavin R. Hierarchical wire routing. IEEE Transactions on Computer-Aided-Design 1983;CAD2:223}34. [18] Cohoon JP, Heck PL. BEAVER: A computational-geometry-based tool for switchbox routing. IEEE Transactions on Computer-Aided-Design 1988;CAD-7:684}97. [19] Luk WK. A greedy switchbox router. Integration 1985;3:129}49. [20] Nemhauser GL, Wolsey LA. Integer and combinatorial optimization. New York: Wiley, 1988. [21] Hwang FK, Richards DS. Steiner tree problems. Networks 1992;22:55}89. [22] Winter P. The Steiner problem in networks: A survey. Networks 1987;17:129}67. [23] Erickson RE, Monma CL, Veinott Jr. AF. Send-and-split method for minimum-concave-cost network #ows. Mathematics of Operation Research 1987;12:634}65. Gue-woong Jeong is a Ph.D. student of industrial engineering at the Korea Advanced Institute of Science and Technology (KAIST). He received the B.S. and M.S. degrees in industrial engineering from KAIST. His research interests include network reliability, integer programming and combinatorial optimization. Kyungsik Lee is a senior member of technical sta! at the Department of Postal Technology of Electronics and Telecommunications Research Institute. He "nished his undergraduate study at the department of industrial engineering of Seoul National University in 1993 and received M.S. and Ph.D. degrees in industrial engineering from KAIST in 1995 and 1998, respectively. His current research interests include the theory of integer programming and combinatorial optimization, telecommunication network planning and design, and supply chain management and logistics information systems. Sungsoo Park received the B.S. and M.S. degrees in industrial engineering from Seoul National University in 1980 and 1982, and the Ph.D. degree in operations research from Cornell University in 1989, respectively. Since 1990, he has been with the department of industrial engineering at KAIST. His research interests include integer programming and combinatorial optimization, telecommunication network planning and design, mathematical models in production and distribution systems. Kyungchul Park is a senior member of technical sta! in the Telecommunication Network Lab of Korea Telecom. He received his Ph.D. degree in industrial engineering from KAIST. His current research interest includes combinatorial optimization, integer programming and telecommunication network design.