Exact algorithms for the Steiner tree problem

(1)

Exact Algorithms for the Steiner Tree

Problem

(2)

Organization for Scientific Research (NWO) grant 500.30.204 (exact algo-rithms) and carried out at the group of Discrete Mathematics and Mathe-matical Programming (DMMP), Department of Applied Mathematics, Fac-ulty of Electrical Engineering, Mathematics and Computer Science of the University of Twente, the Netherlands.

Netherlands Organization for Scientific Research NWO Grant 500.30.204

Exact algorithms.

UT/EWI/TW/DMMP Enschede, the Netherlands.

UT/CTIT

Enschede, the Netherlands.

The financial support from University of Twente for this research work is gratefully acknowledged. The printing of this thesis is also partly supported by CTIT, University of Twente.

The thesis was typeset in LA_{TEX by the author and printed by W¨ohrmann}

Printing Service, Zutphen.

Copyright c Xinhui Wang, Enschede, 2008. ISBN 978-90-365-2660-9

ISSN 1381-3617 (CTIT Ph.D. thesis Series No. 08-116)

All rights reserved. No part of this work may be reproduced, stored in a retrieval system, or transmitted in any form or by any means, electronic, mechanical, photocopying, recording, or otherwise, without prior permis-sion from the copyright owner.

(3)

EXACT ALGORITHMS FOR THE STEINER TREE PROBLEM

DISSERTATION

to obtain

the degree of doctor at the University of Twente, on the authority of the rector magnificus,

prof. dr. W. H. M. Zijm,

on account of the decision of the graduation committee, to be publicly defended on Wednesday 25th _{of June 2008 at 15.00 hrs} by Xinhui Wang born on 11th _{of February 1978} in Henan, China.

(4)

prof. dr. Gerhard J. Woeginger and the assistant promoter,

(5)

List of Figures

2.1 Example of sliding . . . 20

2.2 Example of flipping . . . 21

2.3 Full component: type 1 . . . 22

2.4 Full component: type 2 . . . 22

2.5 Proof of Hwang’s theorem: case 1 . . . 24

2.6 Proof of Hwang’s theorem: case 2 . . . 24

2.7 Labelling the nodes in a component. . . 25

2.8 Diamonds must be empty. . . 26

2.9 Rectangles must be empty. . . 26

2.10 A nonempty rectangle. . . 27

2.11 Triangles must be empty. . . 28

2.12 Weak triangle condition. . . 28

2.13 Proof of Lemma 2.2.5. . . 29

2.14 Proof of Lemma 2.2.6. . . 30

2.15 Proof of Lemma 2.2.7 . . . 30

3.1 3-Splits . . . 42

3.2 3-Splits subtrees . . . 42

3.3 Spliting the optimum tree into components . . . 46

3.4 Subtrees . . . 46 3.5 ASC algorithm . . . 47 4.1 Hwang tree . . . 56 4.2 Terminals in a component. . . 57 4.3 Diamonds . . . 58 4.4 Rectangles . . . 58

(10)

4.5 Triangles . . . 59

4.6 T + e. . . 60

4.7 Triangle condition: case 1 . . . 61

4.8 Triangle condition: case 2 . . . 61

4.9 Empty circles. . . 62

4.10 Terminals above and below the chain. . . 62

4.11 11 is forbidden for yiyj. . . 63

4.12 10 is forbidden for yiyi+1. . . 64

4.13 Illustration of Lemma 4.3.3. . . 64

4.14 Feasible regions for yi and yi′. . . 65

4.15 A tight worst case example. . . 70

4.16 Tree star in forbidden case 1 . . . 72

4.17 Subtree T in forbidden case 1 . . . 72

4.18 Subtree T∗ in forbidden case 1 . . . 73

4.19 yiyi+1yi+2yi+3= 1001 is allowed . . . 73

4.20 yi+1yi+2yi+3yi+4= 1001 is allowed . . . 74

4.24 Tree star in forbidden case 2 . . . 79

4.25 Subtree T in forbidden case 2 . . . 79

4.26 Subtree T∗ in forbidden case 2 . . . 80

4.27 yiyi+1yi+2yi+3= 1001 is allowed . . . 80

4.30 Structure tree: case 1 . . . 84

4.31 Structure tree: case 2 . . . 85

4.32 Structure tree: case 3.1 . . . 85

4.33 Structure tree: case 3.2 . . . 86

4.34 The case with d′_i > d′_i+1 . . . 87

4.35 Local maximal point . . . 87

4.36 Local minimal point . . . 88

4.37 The case with yj = 0 . . . 88

4.38 Local minimal point and local maximal point . . . 89

4.39 The case with j_{≤ i + 2 . . . .} 90

(11)

LIST OF FIGURES vii

4.41 T∗ _{in T -branch condition . . . .} ₉₁

4.42 yj is the maximum one . . . 92

4.43 yj is the middle one . . . 92

4.44 T in the example . . . 93

4.45 T∗ in the example . . . 93

4.46 Subtree of a monotone tree star . . . 94

4.47 Above layer and below layer . . . 94

4.48 Connection to the left subtree . . . 95

4.49 Forbidden connection . . . 95

4.50 Possible connections . . . 96

4.51 yi directly connects to y′i . . . 97

A.1 Monotone tree star . . . 105

A.2 One possible case of path p . . . 105

A.3 The case j < i . . . 106

A.4 The case j > i + 2 . . . 107

A.5 yiyi+2 is forbidden . . . 107

A.6 yi+1 directly connects to yi+2 . . . 107

A.7 Horizontal segment . . . 108

A.8 mn is above the original chain . . . 108

A.9 y_i′ directly connects to y′_j with j > i . . . 109

A.10 y′ i directly connects to y′j with j < i . . . 109

A.11 The path is over y_i−1. . . 110

A.12 mn is above the chain . . . 111

A.13 mn is below the chain . . . 111

A.14 p is over yi+1 . . . 112

A.15 p is below y′ i . . . 113

A.16 p is between yi and yi+1′ . . . 113

A.17 yi directly connects to y′_i−2 . . . 114

A.18 yi directly connects to y′i . . . 115

A.19 The forbidden of yi directly connecting to y′i . . . 116

A.20 yi directly connects to yi+1 . . . 116

A.21 Topological structure of yi directly connecting to yi+1 . . . 117

A.22 yi directly connects to y′i and yi+1 . . . 117

A.23 yi directly connects to y′i and yi+1 . . . 118

A.24 yi directly connects to yi−1 and yi′ . . . 118

(12)

A.26 yi directly connects to y_i−1′ , yi−1and yi′ . . . 119

A.27 yi directly connects to y_i−1′ , yi−1and yi′ . . . 119

A.28 The possible structure . . . 120

A.29 yi, y′i, yi+1, yi−1and yi−1′ are a part of a tree star . . . 120

A.30 yi, y′i, yi+1, yi−1and yi−1′ contain a tree star . . . 120

(13)

List of Tables

3.1 The complexity of computing subsets . . . 37

3.2 Polynomial bound and exponential bound . . . 43

3.3 O(ǫp−1) and 1_ǫ . . . 53

(14)

(15)

Chapter 1

Introduction

The definitions and the algorithms for the Steiner tree problem will be introduced in this chapter.

1.1 The Steiner tree problem

After more than 26 years of war, emperor Qinshi Huangdi finally con-quered the other six Chinese countries and built the first powerful central-ized state in 221 BC. In order to consolidate and strengthen the empire, the emperor wanted to build a road-network which would connect some main cities of the seven countries. From the economic view, the newly es-tablished road-network should be as short as possible and be built on the basis of existing roads. However, which roads should be selected then? It was a big problem for Qingshi Huangdi in his time.

Actually, Qinshi Huangdi’s problem can be transformed to a problem on an undirected graph G = (V, E, w), where V is the vertex set, E is the edge set, and w vector of edge weight. In this graph, each city is represented by a vertex v, the road between these cities are edges e, and the length of each road is the weight of the corresponding edge. The main cities that need to be connected from a subset Y of V . The set Y is called terminal set and the points in this set are called terminal points/terminals. Then Qinshi Huangdi’s problem can be treated as a kind of Steiner tree problem (STP) ([65, 70, 64, 79, 30]), which is defined as follows.

(16)

Definition 1.1.1. Given an undirected graph G = (V, E, w) and a sub-set Y of V , the Steiner tree problem is to find the shortest subtree (the shortest sum weight of edges in this tree) of G which connects all the points in Y .

The Steiner tree problem is a classical N P − hard combinatorial opti-mization problem ([70, 52]). It has wide applications in various scientific and technological fields such as Very-Large-Scale-Integration (VLSI) design ([76, 74]), communication ([77]), transportation sectors design ([78]), and perfect phylogeny in bioinformatics [5].

1.1.1 History of the Steiner tree problem

The Steiner tree problem is a combinatorial variant of the former Eu-clidean Steiner tree problem [75], which was investigated in the seventeenth century by the French mathematician Pierre Fermat as follows (A more de-tailed history of the Steiner tree problem can be found in [65]).

Problem 1.1.1. Find a point p in a triangle, such that the sum of the distances from p to the three vertices is minimized.

This problem is known as the Fermat problem. It was solved by Torricelli with a geometric solution before 1640. Several years later, Cavalieri showed an important aspect of this problem, namely that the line segments from the given three points make a 120◦ degree angle with each other.

Simpson proposed a general version of Fermat’s problem in his book “Fluxions” as

Problem 1.1.2. Find a point p in a plane with the minimum sum of distances from p to n given points.

Many mathematicians were attracted to work on Simpson’s problem. In 1934, Jarnik and K¨ossler [68] presented another kind of problem – shortest interconnection network problem as

Problem 1.1.3. Find a shortest network which interconnects n given points in a plane.

(17)

1.1.2 Related problems 3 The shortest interconnection network problem is different from the Fer-mat problem, except for the case n = 3. Courant and Robbins [24] com-bined these two problems and referred to the shortest interconnection net-work problem as the Steiner problem which is named the great German mathematician Jakob Steiner for his contribution to projective geometry, al-though Steiner’s contribution to the Steiner tree problem is unclear. Gilbert and Pollak [54] further referred to the shortest interconnection network problem in a graph as the Steiner tree problem since the shortest network in a graph should be a tree.

1.1.2 Related problems

Many different variants and generalizations of the Steiner tree problem have been investigated in the literature. Here we only list some important examples.

• Euclidean Steiner tree Problem [108, 66, 103, 29] (ESTP): Given a finite set Y of points in the (Euclidean) plane, find a point set R together with a minimal spanning tree T for R_{∪ Y , such that T has} a minimum length in the ℓ2− norm1 (Euclidean distance).

• Rectilinear Steiner tree problem [41, 47, 58, 61, 63] (RSTP): Given a finite set Y of points in the (Euclidean) plane, find a point set R together with a minimal spanning tree T for R_{∪ Y , such that T has a} minimum length in the ℓ1− norm2 (Manhattan/rectilinear distance).

• Directed Steiner tree problem [65, 106, 83]: Given a directed graph G = (V, A, w) where A is the set of directed arcs, a subset Y of V , and a root terminal z1, find a directed shortest subtree, such that

there is a path from z1 to any point in Y .

• Generalized Steiner tree problem [73, 69, 93]: Given an undirected graph G = (V, E, w), a subset Y of V , and partitions{Y1, Y2,· · · , Yk},

find a shortest tree T , such that at least one point from each Yi is in

T .

1_{For two points a = (x}

1, y1) and b = (x2, y2), the distance in ℓ2− norm (Euclidean

distance) is d(a, b) =p(x1− x2)2+ (y1− y2)2. 2_{For two points a = (x}

1, y1) and b = (x2, y2), the distance in ℓ1− norm

(18)

• Weighted Steiner tree problem [96, 33]: Given an undirected graph G = (V, E, w, c), where c is a weight vector of vertices, and a subset Y of V , find a tree T spanning all the points in Y , such that the total weight of edges and vertices in T is minimum.

Some special cases of STP which can be solved efficiently are also very interesting. For instance,

• If k = 2, STP is a shortest path problem between the two given terminals. The solution can be obtained in polynomial time in the input size [23, 25].

• If k = 3, STP is a general version of the Fermat problem. For three given points z1, z2 and z3, STP is to find a vertex v that minimizes

d(v; z1) + d(v; z2) + d(v; z3). The solution can be obtained in time O(m + nlogn).

• If k = n, STP is a minimal spanning tree problem (MSTP) of G [23, 55, 46, 34]. Here too it is still a problem to find a shortest tree that connects all the vertices. The solution can be obtained in time O(m + nlogn) ([23, 25]) as well.

Note that the difference between STP and MSTP: although they both connect the terminal points in Y , STP contains some extra points to reduce the tree length. These extra points in STP are known as the Steiner points. Various algorithms have been proposed for solving STP such as ex-act algorithms [77, 30, 13, 18, 21, 48, 49, 94, 97, 4, 6, 57], approxima-tion algorithms [17, 7, 10, 13, 102, 89, 53, 56] and heuristic algorithms [81, 19, 9, 71, 60, 13, 92]. This thesis focuses mainly on exact algorithms for the Steiner tree problem. Before explaining these algorithms, we will introduce some background of the Steiner tree problem. In Section 2, the definition of N P_{−hardness will be explained. In Section 3, we will describe} some exact algorithms and approximation algorithms for the Steiner tree problem. Parameterized algorithms will be explained as well in Section 3 since the exact algorithms for the STP belong to such algorithms. Results of two special Steiner tree problems will be discussed in Section 4. Finally, our contributions and the structure of this thesis will be described.

(19)

1.2 N P -hardness 5

1.2 N P -hardness

Considering that the Steiner tree problem is N P− hard, we will briefly introduce the definition of N P _{− hard and some other related definitions} and notions. For more details about N P -hardness, we refer to [52, 86].

1.2.1 Definitions and notions

In this thesis, we will focus two kinds of problems: optimization problem and decision problem. We will start with the definition of the optimization problem.

The optimization problem is a problem Π = (_{I, F, c), where I is a set of} instances,_{F is a set of the satisfied solution F(I) (I ∈ I), and each instance} I has an associated objective function c : F(I) → R1_{. An optimization}

problem is either a minimization problem or a maximization problem. The minimization problem is to find the solution with the minimum objective value, i.e., to find an x ∈ F(I) such that c(x) ≤ c(y) for all y ∈ F(I), while the maximization problem is to find the solution with the maximum objective value. Here, x is called the optimum solution and c(x) called the optimum value. The optimization version of the Steiner tree problem can be described as

Example 1.2.1. Given an undirected weighted graph G = (V, E, w) and a subset Y of V , find a shortest subtree which connects all points in Y . The second kind of problem is the decision problem. The decision prob-lem is a probprob-lem Π = (_{I, I}+), where_{I is a set of instances and I}+is a set of “yes” instances, clearly, _I+ _{⊆ I. The decision problem is to answer the}

question whether an instance I belongs to a set of instanceI+ _{or not. The}

decision version of the Steiner tree problem can be written as

Example 1.2.2. ([65]) Given an undirected graph G = (V, E, w), a subset Y of V and a value i, is there a Steiner tree T spanning Y with the length of T is shorter than i?

Each optimization problem has a corresponding decision version. For the minimization problem, that has an instance I and a given value i, the corresponding decision problem is to detect whether I belongs to_I+_{or not,}

where

(20)

For both decision problem and optimization problem, the final answer can be calculated or recognized with an algorithm A. The algorithm A is a step by step procedure or instruction for any instance of a problem. The algorithm _{A stops when all the instructions are performed, and gives} as output a final solution for each input instance I. The length _{|I| of an} instance I in a problem Π is called the size of input, which is defined as the number of symbols in the description of I for Π. The number of steps that it takes on an instance of the problem is called the time complexity, which normally is a function with respect to the size of input. If the complexity of an algorithm is f (n), and there exists a g(n) with some constant c > 0 such that f (n)≤ cg(n) for large enough n, the complexity would be written as O(g(n)).

Polynomial time refers to the computation time of a problem where the final solution can be obtained within p(_{|I|) steps, where p(|I|) is a} polynomial function of _{|I|. An algorithm running in polynomial time is} called “efficient”. The decision problem that can be solved in polynomial time is known as the class “P ”. Problems in P are considered to be “easy problems”.

1.2.2 The class N P

Many interesting problems can be solved in polynomial time, while oth-ers can not. Therefore, a richer class of decision problems, the class N P (Non-deterministic Polynomial time), is introduced. The definitions of N P , N P _{− complete and NP − hard will be explained in the following section.} A certificate is a witness or a proof for the right guess that I_{∈ I}+. In the decision version of the Steiner tree problem, the certificate is a tree T∗

which is used to prove the existence of such a tree with a length less than i. Let c be the certificate for a “yes” instance I, whose length is polynomially bounded by the size of I. The decision problem Π is in N P , if, for a given instance I of Π and a given certificate c for I, there exists a polynomial time algorithm _{A with input instance I and certificate c such that A will} output a “yes” answer if and only if I _{∈ I}+_{. The algorithm} _{A is called a}

certificate checking algorithm.

The class N P contains all decision problems that can be checked in poly-nomial time. For a guessed right certificate, the instance can be checked in polynomial time with algorithm_{A, which is, hence, named non-deterministic}

(21)

1.2.2 The class N P 7 polynomial time. When a problem is in N P , it is not required that the so-lution of each instance can be obtained by an algorithm in polynomial time. It only requires that there exists a certificate if I is a “yes” instance and the validity of this certificate can be checked in polynomial time.

Take the Steiner tree problem, for example, the obvious way to solve this problem is by exhaustive search, which is to check all possible trees until the optimum tree is obtained. The worst case is always in exponential time. However, this problem is in N P since for a witness tree (certificate) T with a length less than a given i (a “yes” instance), the length of the tree can be calculated in polynomial time.

P _{⊆ NP can be proved as follows. If a problem is in P , there exists a} polynomial time algorithm_{A for “solving” this problem. A can be used to} give each possible certificate. Thus this problem is in N P . However, it is still an open problem whether P = N P or P _{6= NP . It is now commonly} believed that P _{6= NP due to the existence of another class: NP −complete} problem.

What is N P_{− complete? Before giving its definition, we should explain} what is polynomially reducible. A problem Π1 = (I1,I1+) is polynomially

reducible to another problem Π2 = (I2,I2+) if there exists a polynomial

deterministic algorithm which can transform an instance I1 ∈ I1 into an

instance I2 ∈ I2, such that I2 ∈ I2+ if and only if I1 ∈ I1+. If a problem

Π1 is polynomially reducible to a problem Π2, the algorithm for solving Π2

can be used to solve Π1 as well through transforming the instance of Π1

into the instance of Π2.

The definition of the class N P _{− complete can be described as follows.} A problem Π is N P _{− complete if Π ∈ NP and all other NP problems are} polynomially reducible to Π.

Since the polynomial reduction is transitive, an N P problem Π would be in N P _{− complete if there exists an NP − complete problem which is} polynomially reducible to Π. The first known N P − complete problem is the satisfiability problem [22]. The decision version of the Steiner tree problem was one of Karp’s original 21 N P−complete problems [70] through a reduction from another N P− complete problem, called the Vertex Cover problem [84].

Suppose the problem Π is in P . Because all another N P problems are polynomially reducible to Π1, there are also in P . This means that if an

(22)

N P_{−complete problem would have an algorithm in polynomial time, every} problem in N P could be solved in polynomial time.

NP-complete problems are the hardest problems in NP. If Π2 can be

polynomially reduced to Π1, and Π2 is in N P − complete, and it is given

that Π1is in N P , then Π1is also in N P−complete. However, if a problem Π

can be polynomially reduced from another N P_{−complete problem while it} can NOT be proven to be in N P , it does not belong to the N P− complete class. However, it is at least as hard as the N P _{− complete problems.} Therefore, this kind of problem is referred to as N P _{− hard problem. It} is clear that N P − complete ⊂ NP − hard. Take the decision version of ESTP as an example

Example 1.2.3. Given a set Y of terminals in the Euclidean plane and a value i, is there a Steiner tree T spanning Y , such that _{|T | ≤ i?}

Where _{|T | is the length of tree T .}

This problem is not known (currently) to be in N P . However, it can be proved to be harder than an N P _{− complete problem known as exact} cover by 3-set [65, 50]. Therefore, ESTP is an N P _{− hard problem rather} than an N P − complete problem.

1.3 Algorithms for the Steiner tree problem

As mentioned above, many algorithms have been proposed for solving the Steiner tree problem such as exact algorithms, approximation algo-rithms, online algoalgo-rithms, heuristic algorithms and evolutionary algorithms. In this section, we will introduce the results of exact algorithm and approx-imation algorithm for the Steiner tree problem.

1.3.1 Exact algorithm

An exact algorithm is used to obtain the exact solution for an N P_−hard problem. It is always in exponential time. The problem is therefore thought to be difficult. However, some algorithms with exponential running time have been considered to be acceptable if the size of the problem is not too large. In recent years, many distinct exact algorithms have been presented for different N P _{− hard problems [104, 105, 15, 59, 80, 45, 87, 8, 39, 67,}

(23)

1.3.1 Exact algorithm 9 85, 1, 38, 26, 3, 2, 16, 28]. The main result of exact algorithms is to improve the bounds of the complexity, which is very interesting both from the theoretical and the practical point of view.

The well known exact algorithm for the Steiner tree problem is the dynamic programming method presented by Dreyfus and Wagner [30]. The complexity of this algorithm is O(3k_{· n + 2}k_{· n}2+ n3).

1.3.1.1 Parameterized algorithm

As a kind of exact algorithm for a general N P − hard problem, the parameterized algorithm was firstly investigated by Downey and Fellows in 1990 [27]. This algorithm is to find a solution in polynomial time with respect to the input size and in exponential time with respect to a (small) parameter k [27, 36]. It is also called “fixed parameter tractable” (FPT) algorithm [52], and a problem allowing such an algorithm is called FPT problem.

Downey and Fellows [27] show that STP is fixed parameter tractable in the sense that it can be solved in time O(f (k)g(n)), where f is an exponential function, g is a polynomial function , n is the number of vertices (or edges), and k is a smaller value than n (number of the terminals or other parameter). W.l.o.g., n and k are the number of vertices resp. terminals of STP in this thesis. Then, the algorithms for STP is in time f (k) times a polynomial in n. This complexity is always written as O∗_{(f (k)), since}

the algorithm only takes into account the exponential growth of f (k). For example, the complexity O(n9· 2.684k_{) is written as O}∗_(2.684k_{), since the}

polynomial time part can be suppressed.

1.3.1.2 The Dreyfus-Wagner algorithm for the Steiner tree problem

As mentioned in Section 2, a well known exact algorithm (parameterized algorithm) for the Steiner tree problem is the Dreyfus-Wagner Algorithm [30] in time O(3k_{· n + 2}k_{· n}2+ n3), i.e., O∗(3k). In this section, we will introduce it briefly.

The Dreyfus-Wagner algorithm is a dynamic programming algorithm. It computes the length of a minimum Steiner subtree for a given terminal

(24)

set Y (_{⊂ V ) from its minimum subtrees.}

The crucial observation is as follows. First assume that v is a leaf (a point of degree 1) of the (unknown) optimal tree T (X_{∪ v), where X ⊆ Y .} Then v is joined in T (X_{∪v) to some node w of T (X∪v) along a shortest path} Pvw, such that either w ∈ X or w /∈ X, i.e., w is a Steiner node in T (X ∪v).

In both cases we have T (X∪v) = Pvw∪T (X∪w). In case w is a Steiner node,

it splits T (X_{∪w), i.e., we can decompose T (X ∪w) = T (X}′_{∪w)∪T (X}′′_∪w)

for some nontrivial bipartitions X = X′∪ X′′_{. We may thus write (abusing}

the notation slightly in an obvious way)

T (X_{∪ v) = min P}vw∪ T (X′∪ w) ∪ T (X′′∪ w), (1)

where the minimum is taken over all w_{∈ V and all nontrivial bipartitions} X = X′∪X′′_{. Note that (1) also holds in case w}_{∈ X if we let X}′ _{= X}_\{w}

and X′′ = _{{w}. As well, note that (1) also remains valid without our} assumption of v being a leaf in T (X_{∪ v). Indeed, if v is an internal node} of T (X∪ v), we may simply take w = v (and Pvw= ∅).

Then the Dreyfus-Wagner algorithm can be described as follows, Algorithm 1.3.1. (Dreyfus-Wagner algorithm)[30]

Step 1. Compute Pwv for all w, v∈ V .

Step 2. For i = 2 to k− 1,

For any _{|X| = i and any w ∈ Y , v ∈ V \X}

T (X_{∪ v) = min P}vw∪ T (X′∪ w) ∪ T (X′′∪ w).

The complexity of Step 1, which can be done by Floyd -Warshall algo-rithm [37], is O(n3). Step 2 allows to compute all optimal trees T (X∪ v) for v_{∈ V and X ⊆ Y of size |X| = i for i = 1, 2, · · · , k.}

If w_{∈ X, assuming trees up to level i − 1 have already been computed,} the minimum in (1) for a given X ⊆ Y of size |X| = i can be computed in time O(2i). Hence, the total time of this algorithm is

O( k X i=1 k i · 2i)≤ O(n · 3k).

If w ∈ V \X, compute the minimum in (1) for fixed X ⊆ Y of size |X| = i, where all bipartitions X = X′_∪X′′and all w _{∈ |V \X| can be considered.}

(25)

1.3.2 Approximation algorithm 11 So computing the minimum in (1) takes O(n_{· 2}i_{) and, consequently, the}

complexity of the first recursion is O(n·3k_{). In a similar way, the algorithm}

of the second recursion of Step 2 can be done in O(n2_{· 2}k). Then the total complexity of the Dreyfus-Wagner algorithm is O(n_{· 3}k_{+ n}2_{· 2}k_{+ n}3_{), i.e.,}

O∗₍₃k_).

Note that the Dreyfus-Wagner algorithm can only find the minimum length of a Steiner tree. The minimum Steiner tree itself should be ob-tained by keeping track of the sets and vertices which are atob-tained in the computation of T (X_{∪ {v}).}

1.3.2 Approximation algorithm

In practice, there not exist any algorithm which is efficient enough to find the optimal solution for most large-scale Steiner tree problems. How-ever, it is very important to solve these problems, even if the obtained solution is not optimal. The concept of approximation algorithm is thus introduced for this purpose. An approximation algorithm [99] is to obtain a sub-optimal solution in polynomial time. That the solution is sub-optimal means that it is not too far from the optimal solution or it can reach the optimal solution with a high probability.

The approximation algorithm is always measured with a performance guarantee ratio ρ. An algorithm is said to be a ρ-approximation algorithm if it is in polynomial time and satisfies (in case of a minimization problem) A(I) ≤ ρOP T (I) for any instance I of the problem, where OP T (I) is the optimal value of I and A(I) is the value of the solution obtained by the algorithm _{A. If ρ = 1, the algorithm is an exact algorithm in polynomial} time.

There are many approximation algorithms with different ratios for the Steiner tree problem. The original one is a 2-factor approximation algo-rithm [54] following from the fact that the length of a tour is shorter than 2OP T (I). In 1993, Zelikovsky [111] presented an approximation algorithm with an 11₆ -factor for the Steiner tree problem. One year later, the ratio was improved to 1.75 by Berman and Ramaiyer [9], and further to 1.65 by Karpinski and Zelikovsky [71] in 1997. Hougardy and Pr¨omel [60] further obtained a ratio as 1.60. The best ratio so far was 1 + ln3₂ _{≈ 1.55, which} has been presented by Robins and Zelikovsky [92] with the i-restricted al-gorithm. Meanwhile, Clementi and Trevisan [20] proved that there does

(26)

not exist any approximation algorithm with a ratio less than 1.0006 unless P = N P .

In the following part, we will shortly introduce the 1.55 approximation algorithm presented by Robins and Zelikovsky [92].

Firstly, some notions will be introduced. For more details we refer to [92]. A full Steiner tree for a terminal set Y is a tree T where each terminal point is a leaf. Every Steiner tree can be decomposed into full Steiner subtrees, which are called full components. A tree is called an i-restricted tree if each full component has at most i terminal points.

For any graph G, M ST (G) is the minimum spanning tree of G and w(G) is the sum costs of all edges in G. Let Loss(T ) denote the set of minimum cost edges of tree T , which connect each Steiner point to a terminal, and w(loss(T )) be the cost of Loss(T ). C(T ) is a full component spanning all the terminals of Y , in which two terminals are connected if there is an edge between the corresponding two connected components in Loss(T ). Assume that GS is a complete graph with vertex set Y . Let T be the edge

set of G, and T (G) be the minimum cost graph in G∪ T which contains G and spans all the terminals of Y . The gain of G with respect to T can be denoted as gainT(G) = w(T )− w(T (G)). If G is a Steiner tree,

gainT(G) = cost(T )− cost(G). The i-restricted algorithm can be described

as follows,

Algorithm 1.3.2. i-Loss-Contracting algorithm (i-LCA)[92] Step 1. For a given graph G = (V, E, w) and an integer i, let T = M ST (GS) and H = GS,

Step 2. Find an i-restricted subtree F with maximum r = gainT(F )

w(loss(F )),

Step 3. If r > 0, H = H _{∪ F and T = MST (T ∪ C(F ), go to Step 2;} otherwise go to Step 4.

Step 4. Output the minimum Steiner tree M ST (G). This algorithm has a ratio ρ_{≈ 1 +} ln3₂ < 1.55.

1.4 EST problem and RST problem

Since the ESTP and RSTP have wide applications in practice, some algorithms for these two problems will be shortly introduced in this section as well.

(27)

1.4.1 Algorithms for the EST problem 13

1.4.1 Algorithms for the EST problem

As introduced in Section 1.2, the Euclidean Steiner tree problem (ESTP) is to find a shortest Steiner tree spanning all the points in a given set Y . The distances of any two points are in the ℓ2_{− norm. There are two kinds} of points in the shortest tree: terminal points and Steiner points.

Compared to the Steiner tree problem, the set of potential Steiner nodes in an Euclidean Steiner tree (EST) is infinite and all the plane should be a part of a feasible choice for the Steiner nodes. Since ESTP is defined on an Euclidean plane, it needs to satisfy some geometric properties. In the following part, some results are listed for the ESTP, more details can be found in [110, 103].

Lemma 1.4.1. No two edges in an EST can meet at a point with an angle less than 120◦.

It implies that no vertex in an EST can have more than three edges. Since a Steiner point in an EST has at least three edges, another statement can be obtained,

Lemma 1.4.2. The degree of each Steiner point of an EST is exactly 3.

Thus, each Steiner point has three edges and each terminal point has at least one edge. Assume the number of terminal points is i, then the number of edges in the EST is at least (k + 3i)/2. On the other hand, there are k + i_{− 1 points in the EST, which means that the EST has k + i − 1 edges,} and k + i_{− 1 ≥ (k + 3i)/2, indicating that i ≤ k − 2. The equation holds} if and only if the degree of each terminal point is exactly 1. From Lemma 1.4.2, another lemma can be obtained.

Lemma 1.4.3. The number of Steiner points in an EST is less than k_{− 1.}

An EST with k_{− 2 Steiner points is called a full Euclidian Steiner tree} (FEST), i.e., every terminal point is of degree exactly 1. The total number of FEST’s for a given set with k terminals is 2k−4_k−2/(k_{− 1) ∼}= 4k

16k√πk [14].

Many exact algorithms have been given for the EST problem. The best one was presented by Winter and Zachariasen [103] in 1997. Their

(28)

algorithm has a two-phase scheme: in phase 1, all possible candidates FEST are generated. In phase 2, the EST will be derived from the generated FEST set via dynamic programming or integer programming.

The basic idea of FEST’s generation for a set with k terminals was presented by Melazak [82]. The detailed generation process can be found in [82, 103].

The second phase of the algorithm is to derive the EST from the gen-erated FEST by integer programming, on a hypergraph (Y,F), where Y is the vertex set andF (FEST set) is the hyper edge set. In this hypergraph, let Y (F ) be the terminal points in a FEST of F . It is clear that Fi and

Fj can not appear simultaneously in any EST if they have two or more

common terminal points. Such kind of Fi and Fj are called incompatible.

Let c be a vector with ci = |Fi|, then the following integer programming

problem [103] can be obtained, min cx s.t. P Fi∈F (_{|Y (F}i)| − 1)xi = k− 1, x_Pi+ xj ≤ 1, |Y (Fi)∩ Y (Fj)| ≥ 2 Fi∈F max(0,|Y (Fi)∪ P | − 1)xi ≤ |P | − 1, ∀P ⊆ Y, 2 ≤ |P | ≤ k xi ∈ {0, 1}, ∀Fi ∈ F.

The first constraint is to enforce the number of terminals, while the second constraint is to ensure that the incompatible full components can not appear in the same tree. The last constraint enforces that the tree can not be a cycle. Then EST can be obtained by solving the above integer programming with Branch and Cut methods [103].

Next to various exact algorithms, many approximation algorithms were obtained as well to solve ESTP. The most famous one probably is a √2

3 ≈

1.1547-factor algorithm which was presented by Du and Hwang [31], re-spectively, Takahashi and Matsuyama [98]. The best one was presented by Zelikovsky [112] with a factor (1 + ln√2

3) ≈ 1.1438. On the other hand,

Garey, Graham and Johnson [50] proved that there exists no fully polyno-mial time approximation scheme (FPTAS) algorithm3 unless P = N P .

3_{For each instance I and ǫ > 0, FPTAS-algorithm A finds a solution value A(I) that}

satisfies A(I) ≤ (1 + ǫ)OP T (I), and the running time is polynomial with respect to 1 ǫ

(29)

1.4.2 Algorithms for the RST problem 15

1.4.2 Algorithms for the RST problem

The rectilinear Steiner tree problem asks for the shortest tree connecting all points in a given set Y with a rectilinear distance. This problem was firstly investigated by Hanan [58] on a grid graph, containing only horizontal and vertical lines. RSTP has attracted many interests due to its wide practical applications such as VLSI design, physical synthesis, floor plan, interconnection planning and placement, estimation of wire load, routing congestion and interconnection delay.

The dynamic programming of Dreyfus-Wagner’s algorithm also works for the RSTP, and its complexity is in time O∗(3k). Hwang observed that there exists an optimal tree where each component is a full component (FC). According to Hwang’s statement, Ganley and Cohoon [48] presented an improved dynamic programming algorithm in time O∗(2.62k), by proving a bound O∗(1.62k) on the number of of full components. F¨oßmeier and Kaufmann [40] showed that the number of candidate full components was between 1.32k and 1.38k, yielding an improvement of the running time in the above dynamic programming to O∗(2.38k). A dynamic programming algorithm can obtain the best theoretical worst-case bounds. However, it is only interesting theoretically because of huge memory requirements. RSTP will be introduced in detail in Chapter 2 because some important results of this thesis are about this problem. Here we only summarize the major algorithms for RSTP.

There were many improvements of the approximation algorithms for RSTP. Hwang presented a 3₂-approximation algorithm [31]. Another ap-proximation algorithm with a ratio 11₈ with computing time as O(n3) is presented by Zelikovsky [111]. Berman and Ramaiyer [9] further improved the running time to O(n52) with the same ratio. In 1995, F¨oßmeier and

Kaufmann [41] proposed another algorithm with a ratio 11₈ + _2m1 + 1

8·32r−2

in time O(r· m · n · log2_{n) for any parameters m, r > 0. The most recent}

approximation algorithm was a 1.267-factor algorithm which was proposed by Karpinski and Zelikovsky [71].

Many heuristic algorithms were also used for solving RSTP such as the iterative embedding algorithm [90], Steinerization algorithms [7], and the iterative 1-Steiner heuristic algorithm [72]. We will not go through them in detail since it is beyond the focus of this thesis.

(30)

1.5 Overview and contributions

In this thesis, our work focuses on exact algorithms for the Steiner tree problem and the rectilinear Steiner tree problem. Both STP and RSTP are N P -hard. They have wide applications in practice. Exact algorithms have usually exponential time complexity. Yet, many distinct exact algorithms have been presented for these problems. There exists an optimal RST which can be decomposed into tree stars. The number of tree stars has a great influence on the complexity of the algorithm. The aim of our thesis is to develop the new algorithms for the Steiner tree problem, and the main results are listed as follows,

(1) Two exact algorithms are presented for the Steiner tree problem, (2) Several forbidden cases are provided for the tree star. Some new

upper bounds for the number of tree stars are also obtained. The structure of this thesis is as follows.

In the first chapter, the background of algorithms for the Steiner tree problem is given. We introduce the definition of the Steiner tree problem and the different kinds of Steiner tree problems. For easy understanding of this thesis, the definition of N P -class is also introduced. Moreover, we sum-marize the development of exact algorithms and approximation algorithms for the Steiner tree problem.

In Chapter 2, the properties of the rectilinear Steiner tree, which are useful understanding Chapter 3 and 4, are introduced. The definitions are explained in Section 2.1 and 2.2. The well known exact algorithm, so called two-phase algorithm, is introduced for the rectilinear Steiner tree problem in Section 2.3. This algorithm can be decomposed into two steps: one step is for the generation of full components, and the other step is to combine the optimum tree from the generated full components.

In Chapter 3, we present two novel exact algorithms for the Steiner tree problem. The current best algorithm for the Steiner trees is in time O∗(3k), where k is the number of terminal points. In this chapter, we first present a new algorithm with computing time O∗(2.684k) by showing that the optimum Steiner tree T can be partitioned into T = T1∪ T2∪ T3 and

each Ti is a minimum Steiner tree in a contracted graph Gi with less than

(31)

1.5 Overview and contributions 17 the complexity of present algorithms from O∗_(2.386k_{) to O}∗_(2.335k_{) with}

|Gi| ≤ 0.477k. The ideas and results are based on joint research with B.

Fuchs and W. Kern [42]. Another algorithm is also presented, which is in time O∗_{((2 + δ)}k_{), for any δ > 0. The results are based on the joint work}

with B. Fuchs, W. Kern, D. Molle, S. Richter and P. Rossmanith [43]. In Chapter 4, we mainly discuss the necessary conditions for tree star and candidate components in the rectilinear Steiner tree problem. A new forbidden case is presented for tree stars. The number of tree stars is reduced from O∗(1.386k) to O∗(1.357k). This part work is based on joint work with B. Fuchs and W. Kern [44]. Two necessary conditions for the tree star to be candidate components are also provided. The number of the candidate components is improved correspondingly. Finally, a two-layer tree condition is presented for “monotone tree stars” (the definition can be found in Chapter 4). According to this condition, the possible optimal topological structure of such tree stars is given as well.

(32)

(33)

Chapter 2

Exact algorithm for the

rectilinear Steiner tree

In this chapter, the well known exact algorithm for the rectilinear Steiner tree problem will be introduced. This algorithm was presented by Salowe and Warme [94], who obtained the optimal tree from so-called “full components” (Hwang trees), cf. [48, 95, 41]. In the first part of this chap-ter, the definitions and properties of full components will be introduced. The exact algorithm will be explained in the second part.

2.1 Introduction

Let us start with some definitions and properties of the rectilinear Steiner tree problem.

2.1.1 Definitions and notions

As mentioned in Chapter 1, the rectilinear Steiner tree problem (RSTP) is N P _{− hard [70, 52]. RSTP is to ask for a shortest connection T}∗ _which

spans all points of a terminal set Y using only horizontal and vertical line segments (generically called segments). The points in the terminal set Y are called terminal points, and the number of terminal points is k. The rec-tilinear optimal Steiner tree (RST) may include some points other than the terminal points, which are called Steiner points. That is, the line segments

(34)

of RST intersect at terminal points or Steiner points.

There exist three kinds of Steiner points in the RST: corner point (with degree 2), T-point (with degree 3) and cross point (with degree 4). A complete line is a line with a maximal length, which does not have terminals in its interior but may have terminals at its endpoints. The complete lines connecting the corner point are called legs. A corner point must be incident with a horizontal complete line and a vertical complete line. The corner is called complete corner if the remaining two endpoints are terminals. The two collinear segments connecting at a T node are called the head and the remaining segment is called the body.

A full rectilinear Steiner tree (FRST) is a rectilinear Steiner tree in which all the terminal points are leaves. Any Steiner tree can be decom-posed into some full rectilinear Steiner trees by splitting at all non-leaf terminals. The resulting trees are called the full components (FC) of the Steiner tree.

Some full components can be transformed into others by using two kinds of transformations: sliding and flipping. Sliding means that a segment e is replaced by another segment e′_{, where e and e}′ _{are parallel and intersecting}

parallel lines ℓ1 and ℓ2, both perpendicular to e and e′. According to the

position of these segments, each sliding is named as left-slide, right-slide, up-slide and down-slide. An example of a left-slide is given in Fig. 2.1.

ℓ1 ℓ2 ℓ1 ℓ2 e e e′

Figure 2.1: Example of sliding

Flipping means that two segments e and f meet at a corner-point are replaced with another two segments e′ and f′ such that e, e′, f and f′form a rectangle. Similar to sliding, there are four kinds of flipping as well, named as leftdown-flip, leftup-flip, rightdown-flip, and rightdown-flip. A leftup-flip example is shown in Fig. 2.2.

(35)

2.1.2 Canonical tree 21 e f e f f′ e′

Figure 2.2: Example of flipping

2.1.2 Canonical tree

In a rectilinear Steiner tree problem, there are several possible minimum trees. For example, there are two different minimum trees for a terminal set with only two points (in the Hanan grid1_{). For simplicity, only one kind of}

minimum tree, called canonical tree [65], will be considered in this thesis. Definition 2.1.1. A tree is said to be canonical if it allows none of the following transformations with the same length:

(1) a left-slide,

(2) an upleft-flip or downleft-flip,

(3) an up-slide or down-slide followed by the transformations in (2). The canonical full components in an RST has several properties. Here we only briefly introduce these results, and the detail proof can be referred to [65].

Lemma 2.1.1. In a canonical FRST, no segment is incident to two corner points.

Lemma 2.1.2. In a canonical FRST, if a segment m has no-terminal endpoints, then no two perpendicular segments are incident with the end-points of m from the same side.

Lemma 2.1.3. In a canonical FRST, neighboring segments incident with a leg of corner must alternate.

1_{Hanan grid is a graph which is obtained by constructing vertical and horizontal lines}

(36)

Lemma 2.1.4. In a canonical RST, the body of a T must end at a terminal, and no segments are incident with the body of a T .

Lemma 2.1.5. In a canonical FRST, a head of T is either a leg of a complete corner or a complete line with terminals as endpoints.

2.2 The properties of a full component

In this section, we will firstly present the well-known result (Hwang’s theorem) on the structure of full components (Hwang topology).

2.2.1 Hwang’s theorem

A Hwang tree (or a tree with Hwang topology) is a rectilinear Steiner tree T which can be described as the following two types: the type 1 as in Fig. 2.3 and type 2 as in Fig. 2.4.

r _c

t

Figure 2.3: Full component: type 1

c

t r

Figure 2.4: Full component: type 2

There are two special terminals in both types of full components: the root r and the tip t, which are connected to each other through a horizontal line and a vertical line. These two lines are incident at a common endpoint c⊆ R2 _{(a corner point), which is called the corner of the component. The}

(37)

2.2.1 Hwang’s theorem 23 line [t, c] is called the short leg. The long leg and the short leg are named by the number of incident segments. The long leg has an arbitrary number of straight line segments which are attached to the long leg from both sides alternatingly. Each segment connects exactly one terminal to the chain. In addition, there may be one exceptional terminal connected to the short leg (cf. Fig. 2.4). The Steiner chain is usually drawn in the direction of the positive x-axis as in Fig. 2.3 and Fig. 2.4. The terminals y_{6= r, t that are} attached to the chain from above and below are referred to as upper resp. lower terminals. If the total number of terminals in the Hwang tree is p, then the first type has p_{− 2 alternating segments incident with the long leg} and the second one has p− 3 alternating segments incident with the long leg. The optimal additional terminal attached to the short leg will not be of much interest for our purposes.

Theorem 2.2.1. (Hwang theorem)[62, 65] There always exists an optimal RST whose full components are Hwang trees.

Proof. For simply describing the proof, w.o.l.g., assume that the termi-nal points have different x coordinates and y coordinates, i.e., not any two points share the same x coordinate or y coordinate. The leftmost terminal a in an RST, must be incident with a horizontal complete line or a vertical complete line.

In case it is incident with a horizontal line ℓ1, the other endpoint b of

ℓ1 must be either a T note or a corner point (According to the assumption,

it is not a terminal).

If b is a T note, the horizontal line ℓ1 is the body of the T note. From

Lemma 2.1.4, there are no other segments connecting the horizontal line ℓ1.

Then one of the endpoints (assume c) of head ℓ2 must be a corner point.

(b is not a T note according to the Lemma 2.1.4 and assumption. If b is a terminal, we can only get a full component with three terminal points, and this case is not interesting.) The other horizontal line ℓ3 connecting

the corner point c must be on the other side of ℓ2, otherwise it will

con-trary to Lemma 2.1.2. From Lemma 2.1.1 and Lemma 2.1.2, ℓ3 will end

with a terminal point d, and all the neighboring segments incident to ℓ3

alternatingly. Each segment (for example ℓ4) combines a T node with ℓ3.

According to Lemma 2.1.4, there are no other segments connecting to ℓ4,

i.e., ℓ4 is only incident with one terminal point. Then the whole topology

(38)

c ℓ4 ℓ3 d ℓ₂ ℓ1 a _b

Figure 2.5: Proof of Hwang’s theorem: case 1

If b is a corner point, it must be a complete corner that is incident with ℓ1 and ℓ2 according to Lemma 2.1.1, where ℓ2 is a vertical complete line.

There is only one possible terminal point d connecting the interior of leg ℓ2 according to Lemma 2.1.2 and 2.1.4. Then all the other segments (for

example ℓ4) are incident with the complete line ℓ1 alternatingly according

to Lemma 2.1.3. There are no other segments connected to ℓ4 according to

Lemma 2.1.4. Thus we get the topology structure of a Hwang tree of type 1 or type 2 as in Fig. 2.6. a ℓ4 ℓ1 d ℓ2 b

Figure 2.6: Proof of Hwang’s theorem: case 2

In case a is incident with vertical line ℓ1, similar to the above analysis,

we can get a Hwang tree of type 1 with ℓ1 as a short leg.

The theorem can be proved by considering the remaining terminals in a similar way.

A Hwang set is a set X (⊆ Y ) which contains at least one Hwang tree. There are several properties for Hwang tree (full component).

(39)

2.2.2 Empty region conditions 25

2.2.2 Empty region conditions

In this section, we will consider an optimal Steiner tree T∗ for an (suit-ably perturbed) instance Y _{∈ R}2. According to Hwang’s theorem [62], we may assume that each component of T∗_{is a Hwang tree with root r}_{∈ Y , tip}

yl+1 ∈ Y and terminals, say, y0, y0′,· · · , yl−1, yl−1′ , yl, y′l, yl+1 alternatively

attached to the chain as in Fig. 2.7. (Possibly an additional terminal yl+2

is joined to the short leg. In what follows, however, we restrict our atten-tion to y0, y′0,· · · , yl, y′l, yl+1, so that we do not have to distinguish between

different types of Hwang trees.)

y_l+1 yl y′_l s′ l s′_l sl+1 r y₀ s₀ s′₀ y′ 0 y1 s₁ yl+2

Figure 2.7: Labelling the nodes in a component.

In a Hwang tree, y0,· · · , yl, yl+1are called as upper terminal points and

y₀′,· · · , y′

l−1, yl′ as lower terminal points. We denote by s0, s0′,· · · , sl, s′l, sl+1

the corresponding Steiner points, which are the projections of the corre-sponding Steiner points onto the chain.

Let S ⊆ R2 _{denote the set of Steiner nodes of T}∗_{. Clearly, being an}

optimal Steiner tree, T∗ _{must be an Minimum spanning tree for the set}

Y ∪ S. For short, we denote MSY (Y ∪ S) as the minimum spanning tree for the set Y _{∪ S. This simple necessary condition on T}∗ in turn implies certain properties of the components of T∗_{. We will present some of these}

properties (empty regions conditions, cf., e.g., [109]) below, including the simple proofs for convenience.

The diamond is a square with diagonal as the line from terminal point to the corresponding Steiner point or the segment that connect two neighbor-ing Steiner points. We observe that T∗ = M ST (Y _{∪ S) implies that every} component of T∗_{, as in Fig.2.8, must have empty diamond in the sense}

that the interior of each diamond may not contain any terminal y∈ Y (cf. Fig.2.8).

(40)

yl+1 y′_l r y0 y₀′ y1

Figure 2.8: Diamonds must be empty. Lemma 2.2.2. [109] Diamonds must be empty.

Proof. Assume to the contrary, that for some component, say, a dia-mond D = D[yi, si] with diagonal [yi, si], contains a terminal y∈ Y in its

interior. Let y′ denote the projection of y onto [yi, si]. Adding, e := [y, y′]

to T∗ _{closes a circuit that contains either f := [y}′_{, y}_i_{] or f := [y}′_{, s}_i_{]. In}

both cases, T∗\_f_{∪ e would be a shorter tree, a contradiction.}

Emptiness of diamonds of the form D = D[s′_i−1, si] or D = D[si, s′i]

follows in the same way.

Next we consider rectangles R = R[yi, yi′] and R = R[yi′, yi+1], defined

by their diagonal endpoints (yi, y′i) resp. (y′i, yi+1) (see Fig. 2.9). Again,

rectangles must be the empty regions in the above sense.

y_i y_i−1 y′ i−1 y0 y′₀ _y′ 1 y₁ r

Figure 2.9: Rectangles must be empty.

(41)

2.2.2 Empty region conditions 27 Proof. Assume to the contrary, that for some component, say, a com-ponent of T∗ contains a nonempty rectangle, R = R[yi, s′i]. So R contains

some y _{∈ Y in its interior. The rectangle R has sides e = [y}i, si] and

f = [si, s′i]. Let ye and yf denote the projections of y onto e resp. f as in

Fig. 2.10. s_i y y_f y_e s′ i yi

Figure 2.10: A nonempty rectangle.

We may assume, w.l.o.g., that, say, y is closer to e than to f . Removing the segment [ye, si] from T∗splits T∗into two subtrees T1 and T2containing

yeresp. yf. If y∈ T2, then T1∪T2∪[y, ye] is shorter than T∗, a contradiction.

Hence y _{∈ T}1 must hold. But then T1\[yi, ye]∪ T2∪ [y, yf] is shorter than

T∗.

The empty rectangle condition is rather restrictive: the number of Hwang trees satisfying the empty rectangle condition is O∗(1.42k), cf. [40] (as compared to O∗_(1.62k_{) without this restriction, cf. [48]). This can be}

seen as follows. Any two consecutive terminals yi and yi+2 “above” the

chain uniquely determine the terminal yi+1 in between them on the

oppo-site side of the chain. Namely the one that is closest to the chain. This leads to a bound O∗₍₂k2) = O∗(1.42k) for the number of such Hwang trees

in a straightforward way.

Another empty region condition (cf. [95], [94], [109]) is as the following. Let Bd(x) and Bd(C) denote the l1-balls of radius d > 0 around x ∈ R2

resp. the Steiner chain C. Let di > 0 (d′i > 0) denote the distance of yi

(y_i′) to C. For i = 1,_{· · · , l, l + 1, we let}

∆(yi) := Bdi(yi)∩ Bdi(C)

denote the triangle defined by yi, see Fig. 2.11, ∆(y′i) can be defined in the

(42)

0 1 0 1 00 11 0 0 1 1 00 00 11 11 yi y′_j y′ l s_l+1 r y0

Figure 2.11: Triangles must be empty.

Lemma 2.2.4. ([109]) The triangle can not contain any terminal points of the same Hwang tree.

Proof. If that is impossible, assume terminal point yi is in the triangle

of yi+1 as in Fig. 2.12. A shorter tree can be obtained by deleting segment

yisi and adding the segment yizi+1.

yi yi+1 s_i s_i+1 z_i+1 y_i yi+1 si si+1 y2 y2

Figure 2.12: Weak triangle condition.

The Hwang tree satisfying the above conditions is call a tree star by F¨oßmeier and Kaufmann([40]). F¨oßmeier and Kaufmann further restricted the set of candidates for T∗_{-components by showing that each T}∗_-component

can be assumed to be a tree star. They showed that, in the worst case, the number of tree stars was in between 1.32k and 1.38k.

(43)

2.2.3 Upper bounds for the short leg 29

2.2.3 Upper bounds for the short leg

Next to the empty region conditions, there are also some other condi-tions for the full component, cf. [109]. In this section, several upper bound conditions of the short leg will be introduced.

Let dp be the length of the short leg of type (1) (or the length from the

corner point to the Steiner point on the short leg of type (2)). There are several upper bounds on dp.

Lemma 2.2.5. [109] For each lower terminal point yi in a tree star,

|y′ is′i| ≥ dp. sp zp yp yp yi+1 si+1 yi+1 zi+1 r r yi y′ i si s′ i yi si s′ i y′ i

Figure 2.13: Proof of Lemma 2.2.5.

Proof. For simplicity, in what follows, only the full component with 5 terminal points (one root, two upper terminal points and two lower terminal points) of type (1), as in Fig. 2.13, will be considered. In case of the full component with more terminal points, the lemma can be proved by “sliding” the long leg.

Assume there exists a y′

i such that d′i < dp as in Fig. 2.13. Then two

smaller full components intersecting at y′_ican be obtained. The total length of these two smaller full components is not greater than the length of the original one. Thus the original tree star can be split into two smaller full components.

Lemma 2.2.6. [109] If y′

i is a lower terminal point, yi+1 is the next

upper terminal point, and s′_i resp. si+1 is the projection of yi′ resp. yi+1on

the chain, then |s′

isi+1| ≥ dp.

Proof. If not, assume _|s′

isi+1| < dp, and slide s′isp to zi′yp, where z′i is

the projection of yp on s′iyi′. After deleting the segment spyp and adding

(44)

is obtained from the original one by replacing spyp with s′isi+1. According

to the assumption |s′

isi+1| < dp, the new tree is shorter than the original

one, which is impossible. Thus the lemma holds.

si si yi yi sp yp yp r s′ i y′ i yi+1 si+1 r y′ i s′ i yi+1 si+1 z′ i

Figure 2.14: Proof of Lemma 2.2.6.

Lemma 2.2.7. [109] For each upper terminal yi,|sisi+1|−min(di, di+1)≥

dp.

Proof. If not, assume |sisi+1| − min(di, di+1) < dp, w.o.l.g., suppose

di < di+1, then|sisi+1| − di− dp < 0. Delete the segments s′isp, yi+1si+1

and spyp, add the edge yizi+1 and zi′yp, then a new tree is obtained. For

obtained new tree, we have tree,

= _|sisi+1| + |s′isp| − (|s′isp| + dp+ di+1)

= _|sisi+1| − (dp+ di+1) < 0.

This formula implies that the obtained tree is shorter than the original one, which is impossible. si si yi yi yp r r si+1 yi+1 zp z′ i y′ i yi+1 yp s′ i y′ i s′ i

(45)

2.3 An exact algorithm 31

2.3 An exact algorithm

An exact algorithm for RSTP was presented by Salowe and Warme [94], who used the two-phase scheme algorithm for ESTP to RSTP. The first step of this algorithm is to generate the full components set F, and the second one is to concatenate the optimal tree from the generated full components.

2.3.1 Generation of full components

The algorithm for the generation of (all) full components starts at a given root r and directions for the chain (there are four possible directions from each point). The full component grows along the chain with the root r and in the direction α. When a terminal point is added to the long leg, some long leg tests, such as empty region conditions, will be used to check whether the sequence is a part of FRST. If it is not, this terminal point will be skipped. We proceed to the next terminal node in the direction of the chain.

If yi is accepted as a upper terminal, some upper bound conditions will

be used to check whether yi can be the tip or not. If yes, a full component

is obtained. If not, yi can be added as an upper or lower terminal and we

proceed. For more details, we may refer to the papers [103] and [109]. The process for obtaining a full component with p terminal points will take O(p2) time. Zachariasen stated [109] that the necessary conditions were also sufficient conditions for the optimal full components up to five terminals. In practice, more than 90% of the full components have five or fewer terminals ([109]).

Although the total number of full components can not be proved to be polynomially bounded, there are also several interesting bounds. F¨oßmeier and Kaufmann proved that the upper bound of full components with p terminals was O(kp) ([40]). Salowe and Warme gave an O(k_{· logk) bound} of full components with 3 terminals ([95]). Zachariasen improved the bound for full components with p terminals to O(k·(loglogk)p−2_{), which was almost}

(46)

2.3.2 Construction of the optimal tree

Let F be a full component set, which contains all the possible candi-date full components. There exist three methods for combining the optimal tree from the generated_{F, such as backtrack search, dynamic programming,} and integer programming ([101]). Backtrack search has a very steep run-ning time growth and only can be used for moderate size problems. Dy-namic programming has the better worst case running time theoretically. However, it is very slow in practice due to the huge memory requirement. Integer programming is an efficient algorithm for most problems, which is similar to the algorithm introduced in the first chapter for ESTP.

2.3.2.1 Backtrack search

Backtrack search is a simple algorithm and efficient in practice, we will briefly introduce it as follows.

Two full components Fi and Fj are called disjoint if they have no

com-mon vertex. If Fiand Fj share a common vertex and can appear in the same

RST, they are said to be compatible, cf. [107]. Otherwise, they are called incompatible. For two intersecting full components Fi and Fj in RSTP, the

following two cases are always consider to be incompatible:

(1) There are more than one common vertex in both Fi and Fj (or their

corner flips).

(2) A cycle can be obtained by adding an edge to the embedding of Fi

and Fj, and the added edge is not the longest line in the cycle.

The algorithm starts with a full component, and generates the optimal tree by adding all possible compatible full components to the existing tree. The process will continue until the optimal tree is obtained. The running time of this algorithm in the worst case is 2|F|_{, implying that it is not}

suitable for solving a large scale problem. 2.3.2.2 Dynamic programming

Dynamic programming provides the best worst case bounds for the RST problem. It is desired from the fact that every RST is either an FRST or

(47)

2.3.2 Construction of the optimal tree 33 can be split into an SMT and an FST joined at an interior terminal. Let H(X) be a Hwang tree for X. By slightly misusing the notation, we also interpret T∗(X) as the length of an optimum Steiner tree. In case X _{⊆ Y} is not a Hwang set, we define H(X) =_{∞. It is clear that Hwang trees are} full rectilinear Steiner trees.

Given a full set X ∈ F(Y ), one can (due to the particularly simple structure of full components) easily compute (in linear time) a correspond-ing candidate full tree Tf ull(X). Adopting the notation

X = X1 1 X2 ⇔ X = X1∪ X2,|X1∩ X2| = 1

from [48], we may thus compute minimum Steiner trees for all X ⊆ Y by means of the recursion

T (X) = min Tf ull(X1) ∪ T (X2), (1)

where the minimum is taken over all decompositions X = X1 1 X2 with

X1 ∈ F(Y ) and |X1| ≥ 2. Note that when X ⊆ Y itself is a full set, then

X∈ F(Y ), so we may take X1= X and let X2 be a singleton.

The running time of this procedure depends on the number of candidate full sets. Indeed, letting

F(Y ) := {X1∈ F(Y ) | X1 ⊆ X},

we find that computing the minimum in (1) takes time O∗(|F(Y )|) – assum-ing recursively that T (X2) is known already for all subsets X2 ∈ Y of size

|X2| < |X|. (Recall that, as mentioned above, Tf ull(X1) can be computed

for given X1 ∈ F(Y ) in time O(|X1|) = O(k) = O∗(1).)

Denote the number of full components with i terminals being f (i), then the complexity of algorithm will be

k X i=3 k i · i · f(i).

If the number of full component is αi _{with i terminal points, then the}

complexity is k X i=3 k i · i · αi < k2(1 + α)k.

(48)

An algorithm in time O∗_(2.38k_{) was yielded by F¨oßmeier and Kaufmann}

(49)

Chapter 3

Exact algorithms for the

Steiner tree problem

In this chapter, two novel exact algorithms are presented to solve the Steiner tree problem. Compared with the well-known Dreyfus and Wag-ner’s algorithm, these two algorithms have improved the running time from O∗(3k) to O∗(2.684k) and O∗((2 + δ)k), where δ > 0, respectively.

3.1 The algorithm in time

O

∗

(2.684

k

)

Firstly, we will present the algorithm in O∗(2.684k). This algorithm is included in our paper [42].

3.1.1 Introduction

As mentioned in Chapter 2, the Steiner tree problem (STP) is an NP-hard problem [70]: Given a graph G = (V, E) of order n = _{|V |, edge} costs c ∈ RE

+ and a set Y ⊆ V of k = |Y | terminal nodes, STP is to

find a minimum cost subtree T = T (Y ) of G connecting (spanning) all terminal nodes. The well-known exact algorithm is developed by Dreyfus and Wagner (cf. [30] and Chapter 1), solving minimum Steiner tree problem in general graphs in time O∗(3k) (More details can be referred to Chapter 1).

(50)

which is defined on a grid graph. In this case, RSTP remains to be NP-complete [51], so-called exact algorithm have been designed [40] solving the problem in

O∗(2.386k) = O(poly(n)_{· 2.386}k).

In this section, we will present a modification of the Dreyfus-Wagner algorithm for the Steiner tree problem, yielding an improved complexity of order O∗(2.684k). For the rectilinear case, we slightly modify the F¨oßmeier and Kaufmann’s algorithm [40] and obtain an algorithm in time O∗(2.335k).

3.1.2 Improvement of Dreyfus-Wagner algorithm

Before giving our algorithm, we will firstly introduce the Stirling’s for-mula [35, 91],

Lemma 3.1.1. (Stirling’s lemma) βk αk = O(((1 α) α₍ 1 β− α)β−αβ β₎k_).

Proof. When αk and βk are integer, βk αk = (βk)! (αk)!((β_{− α)k)!}

where αk! is the the factorial of αk, which is the product of all positive integers less than or equal to αk.

According to Stirling’s formula (cf. [35, 91]), i.e. √ 2nπ(n e) n_{≤ n! ≤}√_2nπ(n e) n 12n 12n− 1, we have 12αk−1 12αk 12(βk−αk)−1_{12(βk−αk)} h (β_α)α₍ β β−α)β−α ik ≤ _{αk!((β−α)k)!}βk! ≤ _12αk−112αk h(β_α)α₍ β β−α)β−α ik . This formula yields

Exact algorithms for the Steiner tree problem

Exact Algorithms for the Steiner Tree

Problem

Contents

List of Figures

List of Tables

Chapter 1

Introduction

1.1

The Steiner tree problem

1.2

N P -hardness

1.3

Algorithms for the Steiner tree problem

1.4

EST problem and RST problem

1.5

Overview and contributions

Chapter 2

Exact algorithm for the

rectilinear Steiner tree

2.1

Introduction

2.2

The properties of a full component

2.3

An exact algorithm

Chapter 3

Exact algorithms for the

Steiner tree problem

3.1

The algorithm in time

O

(2.684

)