# Smoothed Analysis of Partitioning Algorithms for Euclidean Functionals

- First Online:

- Received:
- Accepted:

DOI: 10.1007/s00453-012-9643-5

- Cite this article as:
- Bläser, M., Manthey, B. & Rao, B.V.R. Algorithmica (2013) 66: 397. doi:10.1007/s00453-012-9643-5

- 2 Citations
- 795 Downloads

## Abstract

Euclidean optimization problems such as TSP and minimum-length matching admit fast partitioning algorithms that compute near-optimal solutions on typical instances.

In order to explain this performance, we develop a general framework for the application of smoothed analysis to partitioning algorithms for Euclidean optimization problems. Our framework can be used to analyze both the running-time and the approximation ratio of such algorithms. We apply our framework to obtain smoothed analyses of Dyer and Frieze’s partitioning algorithm for Euclidean matching, Karp’s partitioning scheme for the TSP, a heuristic for Steiner trees, and a heuristic for degree-bounded minimum-length spanning trees.

## 1 Introduction

Euclidean optimization problems are a natural class of combinatorial optimization problems. In a Euclidean optimization problem, we are given a set *X* of points in \(\mathbb{R}^{2}\). The topology used is the complete graph of all points, where the Euclidean distance ∥*x*−*y*∥ is the length of the edge connecting the two points *x*,*y*∈*X*.

Many such problems, like the Euclidean traveling salesman problem [22] or the Euclidean Steiner tree problem [14], are NP-hard. For others, like minimum-length perfect matching, there exist polynomial-time algorithms. However, these polynomial-time algorithms are sometimes too slow to solve large instances. Thus, fast heuristics to find near-optimal solutions for Euclidean optimization problems are needed.

A generic approach to design heuristics for Euclidean optimization problems are partitioning algorithms: They divide the Euclidean plane into a number of cells such that each cell contains only a small number of points. This allows us to compute quickly an optimal solution for our optimization problem for the points within each cell. Finally, the solutions of all cells are joined in order to obtain a solution to the whole set of points.

Although this is a rather simple ad-hoc approach, it works surprisingly well and fast in practice [16, 24]. This is at stark contrast to the worst-case performance of partitioning algorithms: They can both be very slow and output solutions that are far from being optimal. Thus, as it is often the case, worst-case analysis is too pessimistic to explain the performance of partitioning algorithms. The reason for this is that worst-case analysis is dominated by artificially constructed instances that often do not resemble practical instances.

Both to explain the performance of partitioning algorithms and to gain probabilistic insights into the structure and value of optimal solutions of Euclidean optimization problems, the average-case performance of partitioning algorithms has been studied a lot. In particular, Steele [31] proved complete convergence of Karp’s partitioning algorithm [18] for Euclidean TSP. Also strong central limit theorems for a wide range of optimization problems are known. We refer to Steele [32] and Yukich [35] for comprehensive surveys.

However, also average-case analysis has its drawback: Random instances usually have very specific properties with overwhelming probability. This is often exploited in average-case analysis: One shows that the algorithm at hand performs very well if the input has some of these properties. But this does not mean that typical instances share these properties. Thus, although a good average-case performance can be an indicator that an algorithm performs well, it often fails to explain the performance convincingly.

In order to explain the performance of partitioning schemes for Euclidean optimization problems, we provide a smoothed analysis. Smoothed analysis has been introduced by Spielman and Teng [27] in order to explain the performance of the simplex method for linear programming. It is a hybrid of worst-case and average-case analysis: An adversary specifies an instance, and this instance is then slightly randomly perturbed. The perturbation can, for instance, model noise from measurement. Since its invention in 2001, smoothed analysis has been applied in a variety of contexts [3, 4, 6, 12, 26]. We refer to two recent surveys [20, 28] for a broader picture.

We develop a general framework for smoothed analysis of partitioning algorithms for optimization problems in the Euclidean plane (Sect. 3). We consider a very general probabilistic model where the adversary specifies *n* density functions *f*_{1},…,*f*_{n}:[0,1]^{2}→[0,*ϕ*], one for each point. Then the actual point set is obtained by drawing *x*_{i} independently from the others according to *f*_{i}. The parameter *ϕ* controls the adversary’s power: The larger *ϕ*, the more powerful the adversary. (See Sect. 2.2 for a formal explanation of the model.) We analyze the expected running-time and approximation performance of a generic partitioning algorithm under this model. The smoothed analysis of the running-time for partitioning algorithms depends crucially on the convexity of the worst-case bound of the running-time of the problem under consideration. The main tool for the analysis of the expected approximation ratio is Rhee’s isoperimetric inequality [25]. Let us note that, even in the average case, convergence to the optimal value for large *n* does not imply a bound on the expected approximation ratio. The reason is that if we compute a very bad solution with very small probability, then this allows convergence results but it deteriorates the expected approximation ratio.

*ϕ*≤log

^{O(1)}

*n*, Dyer and Frieze’s partitioning algorithm for computing matchings [10] has an almost linear running-time, namely

*O*(

*n*log

^{O(1)}

*n*). For

*ϕ*∈

*o*(log

^{2}

*n*), its expected approximation ratio tends to 1 as

*n*increases. The approximation ratios of the partitioning algorithms for TSP and Steiner trees tend to 1 for

*ϕ*∈

*o*(log

*n*). For degree-bounded spanning trees, this is the case for

*ϕ*∈

*o*(log

*n*/loglog

*n*). Our general framework is applicable to many other partitioning algorithms as well, but we focus on the aforementioned problems in this work.

Smoothed bounds for some Euclidean optimization problems

Problem | Running-time | Approximation ratio | Reference |
---|---|---|---|

matching [10] |
| \(1+O(\sqrt{\phi}/\log n)\) | Corollaries 4.2 & 4.5 |

TSP [18] | \(\mathop{\mathrm{poly}}(n)\) | \(1 +O(\sqrt{\phi/\log n})\) | Corollary 5.2 |

Steiner tree [17] | \(\mathop{\mathrm{poly}}(n)\) | \(1 +O(\sqrt{\phi/\log n})\) | Corollary 6.2 |

degree-bounded MST | \(\mathop{\mathrm{poly}}(n)\) | \(1 +O(\sqrt{\phi\log\log n/\log n})\) | Corollary 7.2 |

## 2 Preliminaries

For \(n \in\mathbb{N}\), let [*n*]={1,2,…,*n*}. We denote probabilities by \(\mathbb{P}\) and expected values by \(\mathbb{E}\).

### 2.1 Euclidean Functionals

*Euclidean functional*is a function \(\mathsf {F}:([0,1]^{2})^{\star}\to \mathbb{R}\) that maps a finite point set

*X*⊆[0,1]

^{2}to a real number \(\mathsf{F}(X)\). The following are examples of Euclidean functionals:

\(\mathsf{MM}\) maps a point set to the length of its minimum-length perfect matching (length means Euclidean distance, one point is left out if the cardinality of the point set is odd).

\(\mathsf{TSP}\) maps a point set to the length of its shortest Hamiltonian cycle, i.e., to the length of its optimal traveling salesman tour.

\(\mathsf{MST}\) maps a point set to the length of its minimum-length spanning tree.

\(\mathsf{ST}\) maps a point set to the length of its shortest Steiner tree.

\(\mathsf{dbMST}\) maps a point set to the length of its minimum-length spanning tree, restricted to trees of maximum degree at most

*b*for some given bound*b*.

The Euclidean functionals that we consider in this paper are all associated with an underlying combinatorial optimization problem. Thus, the function value \(\mathsf{F}(X)\) is associated with an optimal solution (minimum-length perfect matching, optimal TSP \(\mathrm{tour},\ldots\)) to the underlying combinatorial optimization problem. In this sense, we can design approximation algorithms for \(\mathsf{F}\): Compute a (near-optimal) solution (where it depends on the functional what a solution actually is; for instance, a perfect matching), and compare the objective value (for instance, the sum of the lengths of its edges) to the function value.

*smooth*[25, 35] if there is a constant

*c*such that

*X*,

*Y*⊆[0,1]

^{2}. The constant

*c*may depend on the function \(\mathsf{F}\), but not on the sets

*X*and

*Y*or their cardinality.

Let *C*_{1},…,*C*_{s} be a partition of [0,1]^{2} into rectangles. We call each *C*_{ℓ} a *cell*. Note that the cells are not necessarily of the same size. For a finite set *X*⊆[0,1]^{2} of *n* points, let *X*_{ℓ}=*X*∩*C*_{ℓ} be the points of *X* in cell *C*_{ℓ}. Let *n*_{ℓ}=|*X*_{ℓ}| be the number of points of *X* in cell *C*_{ℓ}. Let \(\mathop{\mathrm{diameter}}(C_{\ell})\) be the diameter of cell *C*_{ℓ}.

*sub-additive*if

*X*⊆[0,1]

^{2}and all partitioning of the square. \(\mathsf{F}\) is called

*super-additive*if

*X*⊆[0,1]

^{2}and all partitioning of the square. A combination of sub-additivity and super-additivity for a Euclidean functional \(\mathsf{F}\) is a sufficient (but not a necessary) condition for the existence of a partitioning heuristic for approximating \(\mathsf{F}\). We will present such a generic partitioning heuristic in Sect. 3.

*near-additive*if, for all partitions

*C*

_{1},…,

*C*

_{s}of [0,1]

^{2}into cells and for all finite

*X*⊆[0,1]

^{2}, we have

Unfortunately, the Euclidean functionals \(\mathsf{TSP}\), \(\mathsf {MM}\) and \(\mathsf{MST}\) are smooth and sub-additive but not super-additive [31, 32, 35]. However, these functionals can be approximated by their corresponding canonical *boundary functionals*, which are super-additive [13, 35]. We obtain the canonical boundary functional of a Euclidean functional by considering the boundary of the domain as a single point [35]. This means that two points can either be connected directly or via a detour along the boundary. In the latter case, only the lengths of the two edges connecting the two points to the boundary count, walking along the boundary is free of charge. Yukich [35] has shown that this is a sufficient condition for a Euclidean functional to be near-additive.

### Proposition 2.1

(Yukich [35, Lemma 5.7])

*Let*\(\mathsf{F}\)*be a sub*-*additive Euclidean functional*. *Let*\(\mathsf{F}_{\mathop{\mathrm{B}}}\)*be a super*-*additive functional that well*-*approximates*\(\mathsf{F}\). (*This means that*\(|\mathsf{F}(X)-\mathsf{F}_{\mathop{\mathrm{B}}}(X)| = O(1)\)*for all finite**X*⊆[0,1]^{2}.) *Then*\(\mathsf{F}\)*is near*-*additive*.

The functionals \(\mathsf{MM}\), \(\mathsf{TSP}\), \(\mathsf{MST}\), \(\mathsf{ST}\), and \(\mathsf{dbMST}\) are near-additive.

Limit theorems are powerful tools for the analysis of Euclidean functionals. Rhee [25] proved the following limit theorem for smooth Euclidean functionals over [0,1]^{2}. We will mainly use it to bound the probability that \(\mathsf{F}\) assumes a too small function value.

### Theorem 2.2

(Rhee [25])

*Let*

*X*

*be a set of*

*n*

*points drawn independently according to identical distributions from*[0,1]

^{2}.

*Let*\(\mathsf{F}\)

*be a smooth Euclidean functional*.

*Then there exist constants*

*c*

*and*

*c*′

*such that for all*

*t*>0,

*we have*

### Remark 2.3

Rhee proved Theorem 2.2 for the case that *x*_{1},…,*x*_{n} are identically distributed. However, as pointed out by Rhee herself [25], the proof carries over to the case when *x*_{1},…,*x*_{n} are drawn independently but their distributions are not necessarily identical.

### 2.2 Smoothed Analysis

In the classical model of smoothed analysis [27], an adversary specifies a point set \(\bar{X}\), and then this point set is perturbed by independent identically distributed random variables in order to obtain the input set *X*. A different view-point is that the adversary specifies the means of the probability distributions according to which the point set is drawn. This model has been generalized as follows [4]: Instead of only specifying the mean, the adversary can specify a density function for each point, and then we draw the points independently according to their density functions. In order to limit the power of the adversary, we have an upper bound *ϕ* for the densities: The adversary is allowed to specify any density function [0,1]^{2}→[0,*ϕ*]. If *ϕ*=1, then this boils down to the uniform distribution on the unit square [0,1]^{2}. If *ϕ* gets larger, the adversary becomes more powerful and can specify the location of the points more and more precisely. The role of *ϕ* is the same as the role of 1/*σ* in classical smoothed analysis, where *σ* is the standard deviation of the perturbation. We summarize this model formally in the following assumption.

### Assumption 2.4

*Let**ϕ*≥1. *An adversary specifies**n**probability density functions**f*_{1},…,*f*_{n}:[0,1]^{2}→[0,*ϕ*]. *We write**f*=(*f*_{1},…,*f*_{n}) *for short*. *Let**x*_{1},…,*x*_{n}∈[0,1]^{2}*be**n**random vectors where**x*_{i}*is drawn according to**f*_{i}, *independently from the other points*. *Let**X*={*x*_{1},…,*x*_{n}}.

If the actual density functions *f* matter and are not clear from the context, we write *X*∼*f* to denote that *X* is drawn as described above. If we have a performance measure *P* for an algorithm (*P* will be either running-time or approximation ratio in this paper), then the smoothed performance is \(\max_{f} (\mathbb{E}_{X \sim f} [P(X)])\). Note that the smoothed performance is a function of the number *n* of points and the parameter *ϕ*.

Let \(\mathsf{F}\) be a Euclidean functional. For the rest of this paper, let \(\mu_{\mathsf{F}}(n,\phi)\) be a lower bound for the expected value of \(\mathsf{F}\) if *X* is drawn according to the probabilistic model described above. More precisely, \(\mu_{\mathsf{F}}\) is some function that fulfills \(\mu_{\mathsf{F}}(n, \phi) \leq\min_{f} (\mathbb{E}_{X \sim f} [\mathsf{F}(X)])\). The function \(\mu_{\mathsf{F}}\) comes into play when we have to bound the objective value of an optimal solution, i.e., \(\mathsf{F}(X)\), from below in order to analyze the approximation ratio.

## 3 Framework

In this section, we present our framework for the performance analysis of partitioning heuristics for Euclidean functionals. Let \(\mathsf{A}_{\mathop{\mathrm{opt}}}\) be an optimal algorithm for some smooth and near-additive Euclidean functional \(\mathsf{F}\), and let \(\mathsf{A}_{\mathop{\mathrm{join}}}\) be an algorithm that combines solutions for each cell into a global solution. We assume that \(\mathsf{A}_{\mathop{\mathrm{join}}}\) runs in time linear in the number of cells. Then we obtain the following algorithm, which we call \(\mathsf{A}\).

### Algorithm 3.1

(Generic algorithm \(\mathsf{A}\))

**Input**: set

*X*⊆[0,1]

^{2}of

*n*points.

- 1.
Divide [0,1]

^{2}into*s*cells*C*_{1},…,*C*_{s}. - 2.
Compute optimal solutions for each cell using \(\mathsf{A}_{\mathop{\mathrm{opt}}}\).

- 3.
Join the

*s*partial solutions to a solution for*X*using \(\mathsf{A}_{\mathop{\mathrm{join}}}\).

The cells in the first step of Algorithm 3.1 are rectangles. They are not necessarily of the same size (in this paper, only the algorithm for matching divides the unique square into cells of exactly the same size, the other algorithms choose the division into squares depending on the actual point set). We use the following assumptions in our analysis and mention explicitly whenever they are used.

### Assumption 3.2

- 1.
*ϕ*∈*O*(*s*).*This basically implies that the adversary cannot concentrate all points in a too small number of cells*. - 2.
*ϕ*∈*ω*(*s*log*n*/*n*).*This provides a lower bound for the probability mass in a “full” cell*,*where full is defined in Sect*. 3.1. - 3.
\(\phi\in o(\sqrt{n/\log n})\).

*With this assumption*,*the tail bound of Theorem*2.2*becomes sub*-*polynomial*.

These assumptions are not too restrictive: For the partitioning algorithms we analyze here, we have *s*=*O*(*n*/log^{O(1)}*n*) (for matching, we could also use smaller *s* while maintaining polynomial, albeit worse, running-time; for the other problems, we even need *s*=*O*(*n*/log^{O(1)})). Ignoring poly-logarithmic terms, the first and third assumption translate roughly to *ϕ*=*O*(*n*) and \(\phi= o(\sqrt{n})\), respectively. The second assumption roughly says *ϕ*=*ω*(1). But for *ϕ*=*O*(1), we can expect roughly average-case behavior because the adversary has only little influence on the positions of the points.

### 3.1 Smoothed Running-Time

Many of the schemes that we analyze choose the partition in such a way that we have a worst-case upper bound on the number of points in each cell. Other algorithms, like the one for matching [10], have a fixed partition independent of the input points. In the latter case, the running-time also depends on *ϕ*.

*T*(

*n*) denote the worst-case running-time of \(\mathsf{A}_{\mathop{\mathrm{opt}}}\) on

*n*points. Then the running-time of \(\mathsf{A}\) is bounded by \(\sum_{\ell=1}^{s} T(n_{\ell}) + O(s)\), where

*n*

_{ℓ}is the number of points in cell

*C*

_{ℓ}. The expected running-time of \(\mathsf{A}\) is thus bounded by

*T*(the running-time of \(\mathsf{A}_{\mathop{\mathrm{opt}}}\)) is a monotonically increasing convex function and that the locations of the cells are fixed and all their volumes are equal. (The assumption about the cells is not fulfilled for all partitioning heuristics. For instance, Karp’s partitioning scheme [18] chooses the cells not in advance but based on the actual point set. However, in Karp’s scheme, the cells are chosen in such a way that there is a good worst-case upper bound for the number of points per cell, so there is no need for a smoothed analysis.) By slightly abusing notation, let \(f_{i}(C_{\ell}) = \int_{C_{\ell}} f_{i}(x)\,\mathrm{d}x\) be the cumulative density of

*f*

_{i}in the cell

*C*

_{ℓ}. Since

*f*

_{i}is bounded from above by

*ϕ*, we have

*f*

_{i}(

*C*

_{ℓ})≤

*ϕ*/

*s*(this requires that the cells are of equal size, thus their area is 1/

*s*). Let \(f(C_{\ell}) = \sum_{i=1}^{n} f_{i}(C_{\ell})\). Note that \(f_{i}(C_{\ell}) = \mathbb{P}[x_{i} \in C_{\ell}]\) and \(f(C_{\ell}) = \mathbb{E}[n_{\ell}]\).

We call a cell *C*_{ℓ}*full* with respect to *f* if *f*(*C*_{ℓ})=*nϕ*/*s*. We call *C*_{ℓ}*empty* if *f*(*C*_{ℓ})=0. Our bound (1) on the running-time depends only on the values *f*_{1}(*C*_{ℓ}),…,*f*_{n}(*C*_{ℓ}), but not on where exactly within the cells the probability mass is assumed.

*s*/

*ϕ*⌋ full cells. Assume that we have ⌊

*s*/

*ϕ*⌋ full cells and at most one cell that is neither empty nor full. Then the number of points in any full cell is a binomially distributed random variable

*B*with parameters

*n*and

*ϕ*/

*s*. By linearity of expectation, the expected running-time is bounded by

*ϕ*=

*O*(

*s*) by Assumption 3.2(1), this is bounded by \(O(\frac{s}{\phi}\cdot\mathbb{E}[T(B)] + s)\). If

*T*is bounded by a polynomial, then this evaluates to \(O(\frac{s}{\phi}\cdot T(n\phi/s) + s)\) by the following Lemma 3.3. This lemma can be viewed as “Jensen’s inequality in the other direction” with

*p*=

*ϕ*/

*s*for

*ϕ*∈

*ω*(

*s*log

*n*/

*n*). The latter is satisfied by Assumption 3.2(2).

### Lemma 3.3

(Inverse Jensen’s inequality)

*Let**T**be any convex*, *monotonically increasing function that is bounded by a polynomial*, *and let**B**be a binomially distributed random variable with parameters*\(n \in\mathbb{N}\)*and**p*∈[0,1] *with**p*∈*ω*(log*n*/*n*). *Then*\(\mathbb{E}[T(B)] = \varTheta(T(\mathbb{E}[B]))\).

### Proof

*T*is bounded by a polynomial, we have

*T*(2

*np*)=

*O*(

*T*(

*np*)). Since

*p*∈

*ω*(log

*n*/

*n*) and

*T*is bounded by a polynomial, we have (

*e*/4)

^{np}⋅

*T*(

*n*)∈

*o*(1). Thus, \(\mathbb{E}[T(B)] = O(T(np))\), which proves the lemma. □

What remains to be done is to show that the adversary will indeed make as many cells as possible full. This follows essentially from the convexity of the running-time. In the following series of three lemmas, we make the argument rigorous.

The first lemma basically says that we maximize a convex function of a sum of independent 0/1 random variables if we balance the probabilities of the random variables. This is similar to a result by León and Perron [19]. But when we apply Lemma 3.4 in the proof of Lemma 3.5, we have to deal with the additional constraint *p*_{i}∈[*ε*_{i},1−*ε*_{i}]. This makes León and Perron’s result [19] inapplicable.

### Lemma 3.4

*Let**p*∈(0,1). *Let**X*_{1},*X*_{2}*be independent* 0/1 *random variables with*\(\mathbb{P}[X_{1} =1] = p-\delta\)*and*\(\mathbb{P}[X_{2} =1] = p+\delta \). *Let**X*=*X*_{1}+*X*_{2}. *Let**f**be any convex function*, *and let*\(g(\delta) = \mathbb{E}[f(X)]\).

*Then**g**is monotonically decreasing in**δ**for**δ*>0 *and monotonically increasing for**δ*<0 *and has a global maximum at**δ*=0.

### Proof

*δ*by

*z*yields

*f*. □

With Lemma 3.4 above, we can show the following lemma: If we maximize a convex function of *n* 0/1 random variables and this function is symmetric around *n*/2, then we should make all probabilities as small as possible (or all as large as possible) in order to maximize the function.

### Lemma 3.5

*Let**f**be an arbitrary convex function*. *Let**X*_{1},*X*_{2},…,*X*_{n}*be independent* 0/1 *random variables with*\(\mathbb{P}[X_{i} = 1] = p_{i} \in[\varepsilon_{i}, 1-\varepsilon_{i}]\), *and let*\(X = \sum _{i=1}^{n} X_{i}\). *Let*\(g(p_{1},\ldots, p_{n}) = \mathbb{E}[f(X) + f(n-X)]\). *Then**g**has a global maximum at* (*ε*_{1},…,*ε*_{n}).

### Proof

In the following, let \(X' = \sum_{i=1}^{n-1} X_{i}\). Without loss of generality, we can assume that \(\sum_{i=1}^{n} p_{i} \leq n/2\). Otherwise, we replace *p*_{i} by 1−*p*_{i}, which does not change the function value of *g* by symmetry.

*p*

_{i}with

*p*

_{i}>1/2. If there is a

*p*

_{i}>1/2, then there must be a

*p*

_{i′}<1/2 since \(\sum_{i=1}^{n} p_{i} \leq n/2\). Let

*i*=

*n*and

*i*′=

*n*−1 without loss of generality. Our goal is to shift “probability mass” from

*X*

_{n}to

*X*

_{n−1}. To do this, let

*q*=(

*p*

_{n−1}+

*p*

_{n})/2. We consider two new functions \(\tilde{g}\) and

*h*. The function \(\tilde{g}\) is defined by

*X*

_{1},…,

*X*

_{n−2}. The function

*h*is defined by

*h*is convex and we can apply Lemma 3.4: We should choose |

*δ*| as small as possible in order to maximize it. We decrease

*δ*from (

*p*

_{n}−

*p*

_{n−1})/2>0 until

*q*−

*δ*or

*q*+

*δ*becomes 1/2. Then we set

*p*

_{n−1}and

*p*

_{n}accordingly. In this way, we guarantee that

*p*

_{n−1}∈[

*ε*

_{n−1},1−

*ε*

_{n−1}] and

*p*

_{n}∈[

*ε*

_{n},1−

*ε*

_{n}]. We iterate this process until we have

*p*

_{i}≤1/2 for all

*i*∈[

*n*]. This only increases

*F*.

*p*

_{1},…,

*p*

_{n}≤1/2. We finish the proof by showing that decreasing any

*p*

_{i}as much as possible only increases

*g*(

*p*

_{1},…,

*p*

_{n}). Let Δ(

*x*)=

*f*(

*x*+1)−

*f*(

*x*). Since

*f*is convex, Δ is non-decreasing. By symmetry, it suffices to consider

*p*

_{n}. We have Only the term in the last line depends on

*p*

_{n}. Since

*p*

_{i}≤1/2 for all

*i*∈[

*n*−1],

*X*′ is stochastically dominated by

*n*−

*X*′−1. Since Δ is non-decreasing, this yields

*p*

_{n}will never decrease the value of

*g*. □

Lemma 3.5 above is the main ingredient for the proof that the adversary wants as many full cells as possible. Lemma 3.6 below makes this rigorous.

### Lemma 3.6

*Let*

*C*

_{ℓ′}

*and*

*C*

_{ℓ″}

*be any two cells*.

*Let*

*f*

_{1},…,

*f*

_{n}:[0,1]

^{2}→[0,

*ϕ*]

*be any density functions*.

*Let*\(\tilde{f}_{1}, \ldots, \tilde{f}_{n}: [0,1]^{2} \to[0, \phi]\)

*be density functions with the following properties for all*

*i*∈[

*n*]:

- 1.
\(\tilde{f}_{i}(C_{\ell'}) = \min (\phi/s, f_{i}(C_{\ell'}) +f_{i}(C_{\ell''}) )\).

- 2.
\(\tilde{f}_{i}(C_{\ell''}) =(f_{i}(C_{\ell'}) + f_{i}(C_{\ell''}) ) - \tilde{f}_{i}(C_{\ell'})\).

*Note that there are densities*\(\tilde{f}_{1}, \ldots, \tilde{f}_{n}\)

*with these properties*:

*First*,

*all*\(\tilde{f}_{i}\)

*are non*-

*negative and*,

*second*, \(\int_{[0,1]^{2}} \tilde{f}_{i}(x) \,\mathrm{d}x = 1\).

*Furthermore*, \(\tilde{f}_{1}, \ldots, \tilde{f}_{n}\)

*can be chosen such that they are bounded by*

*ϕ*

*since we have*

*f*

_{i}(

*C*

_{ℓ′}),

*f*

_{i}(

*C*

_{ℓ″})≤

*ϕ*/

*s*

*by construction*.)

*Let*

*n*

_{ℓ}

*be the*(

*random*)

*number of points in*

*X*

_{ℓ}

*with respect to*

*f*=(

*f*

_{1},…,

*f*

_{n}),

*and let*\(\tilde{n}_{\ell}\)

*be the*(

*random*)

*number of points in*

*X*

_{ℓ}

*with respect to*\(\tilde{f} = (\tilde{f}_{1}, \ldots, \tilde{f}_{n})\).

*Then*

### Proof

*ℓ*≠

*ℓ*′,

*ℓ*″. Without loss of generality, let

*ℓ*′=1 and

*ℓ*″=2. Thus, we have to prove

*M*={

*i*∣

*x*

_{i}∈

*C*

_{1}∪

*C*

_{2}} be the (random) set of indices of points in the two cells. To prove this, we prove the inequality

*I*⊆[

*n*]. This is equivalent to

*I*=[

*n*]. This gives us the following setting: Any point

*x*

_{i}is either in

*C*

_{1}or in

*C*

_{2}. Under this condition, the probability that

*x*

_{i}is in

*C*

_{1}is \(p_{i} = \frac{f_{i}(C_{1})}{f_{i}(C_{1} \cup C_{2})}\), and the probability that

*x*

_{i}is in

*C*

_{2}is \(1-p_{i} = \frac{f_{i}(C_{2})}{f_{i}(C_{1} \cup C_{2})}\). We can choose

*p*

_{i}arbitrarily such that \(p_{i} \leq\min\{1, \frac{\phi/s}{f_{i}(C_{1})+f_{i}(C_{2})}\} =1-\varepsilon _{i}\) and \(p_{i} \geq\max\{0, 1-\frac{\phi/s}{f_{i}(C_{1})+f_{i}(C_{2})}\}= \varepsilon_{i}\). This is precisely the setting that we need to apply Lemma 3.5. □

*f*

_{1},…,

*f*

_{n}:[0,1]

^{2}→[0,

*ϕ*] be the given distributions. By applying Lemma 3.6 repeatedly for pairs of non-full, non-empty cells

*C*

_{ℓ′}and

*C*

_{ℓ″}, we obtain distributions \(\tilde{f}_{1},\ldots, \tilde{f}_{n}\) with the following properties:

- 1.
\(\tilde{f}_{1},\ldots, \tilde{f}_{n}\) have ⌊

*s*/*ϕ*⌋ full cells and at most one cell that is neither full nor empty. - 2.
The expected value of

*T*on*X*sampled according to \(\tilde{f}_{1},\ldots\tilde{f}_{n}\) is not smaller than the expected value of*T*on*X*sampled according to*f*_{1},…,*f*_{n}.

### Theorem 3.7

*Assume that the running*-

*time of*\(\mathsf{A}_{\mathop{\mathrm{opt}}}\)

*can be bounded from above by a convex function*

*T*

*that is bounded by a polynomial*.

*Then*,

*under Assumptions*2.4, 3.2(1),

*and*3.2(2),

*the expected running*-

*time of*\(\mathsf{A}\)

*on input*

*X*

*is bounded from above by*

### Proof

*s*/

*ϕ*⌋ cells that are full plus possibly one cell containing all the remaining probability mass. The expected running-time for each such cell is

*O*(

*T*(

*nϕ*/

*s*)) by Lemma 3.3 and because of Assumption 3.2(2). Thus, the expected running-time of \(\mathsf{A}\) is bounded from above by

*ϕ*=

*O*(

*s*) by Assumption 3.2(1). □

### 3.2 Smoothed Approximation Ratio

*J*′ is an upper bound for the cost incurred by joining the solution for the cells. Since \(\mathsf{F}\) is a near-additive Euclidean functional, we have \(\mathsf{A}(X) \leq\mathsf{F}(X) + J\) for \(J = J' + O(\sum_{\ell=1}^{s} \mathop{\mathrm{diameter}}(C_{\ell}))\). Dividing by \(\mathsf{F}(X)\) yields

For estimating the expected approximation ratio \(\mathbb{E}[\mathsf{A}(X)/\mathsf{F}(X)]\) for some algorithm \(\mathsf{A}\), the main challenge is that \(\mathsf{F}(X)\) stands in the denominator. Thus, even if we have a good (deterministic) upper bound for \(\mathsf{A}(X)\) that we can plug into the expected ratio in order to get an upper bound for the ratio that only depends on \(\mathsf{F}(X)\), we are basically left with the problem of estimating \(\mathbb{E}[1/\mathsf{F}(X)]\). Jensen’s inequality yields \(\mathbb{E}[1/\mathsf{F}(X)] \geq1/\mathbb{E}[\mathsf{F}(X)]\). But this does not help, as we need upper bounds for \(\mathbb{E}[1/\mathsf{F}(X)]\). Unfortunately, such upper bounds cannot be derived easily from \(1/\mathbb{E}[\mathsf{F}(X)]\). The problem is that we need strong upper bounds for the probability that \(\mathsf{F}(X)\) is close to 0. Theorem 2.2 is too weak for this. This problem of bounding the expected value of the inverse of the optimal objective value arises frequently in bounding expected approximation ratios [11, 12].

There are two ways to attack this problem: The first and easiest way is if \(\mathsf{A}\) comes with a worst-case guarantee *α*(*n*) on its approximation ratio for instances of *n* points. Then we can apply Theorem 2.2 to bound \(\mathsf{F}(X)\) from below. If \(\mathsf{F}(X) \geq\mu _{\mathsf{F}}(n,\phi)/2\), then we can use (2) to obtain a ratio of \(1+O(\frac{J}{\mu_{\mathsf{F}}(n, \phi)})\). Otherwise, we obtain a ratio of *α*(*n*). If *α*(*n*) is not too large compared to the tail bound obtained from Theorem 2.2, then this contributes only little to the expected approximation ratio. The following theorem formalizes this.

### Theorem 3.8

*Assume that*\(\mathsf{A}\)

*has a worst*-

*case approximation ratio of*

*α*(

*n*)

*for any instance consisting of*

*n*

*points*.

*Then*,

*under Assumption*2.4,

*the expected approximation ratio of*\(\mathsf{A}\)

*is*

*for some positive constant*

*c*>0.

### Proof

*c*,

*c*′>0. Together with (3), this allows us to bound the expected approximation ratio as

Now we turn to the case that the worst-case approximation ratio of \(\mathsf{A}\) cannot be bounded by some *α*(*n*). In order to be able to bound the expected approximation ratio, we need an upper bound on \(\mathbb{E}[1/\mathsf{F}(X)]\). Note that we do not explicitly provide an upper bound for \(\mathbb{E}[1/\mathsf {F}(X)]\), but only a sufficiently strong tail bound *h*_{n} for \(1/\mathsf{F}(X)\).

### Theorem 3.9

*Assume that there exists a*

*β*≤

*J*

*and a function*

*h*

_{n}

*such that*\(\mathbb{P}[\mathsf{F}(X) \leq x] \leq h_{n}(x)\)

*for all*

*x*∈[0,

*β*].

*Then*,

*under Assumption*2.4,

*the expected approximation ratio of*\(\mathsf{A}\)

*is*

### Proof

*C*>0. If we still have \(\mathsf{F}(X) \geq\beta\), then we can bound the ratio from above by

*β*≤

*J*. We are left with the case that \(\mathsf{F}(X) \leq\beta\). This case contributes

## 4 Matching

As a first example, we apply our framework to the matching functional \(\mathsf{MM}\) defined by the Euclidean minimum-length perfect matching problem. A partitioning algorithm for approximating \(\mathsf{MM}\) was proposed by Dyer and Frieze [10]. For completeness, let us describe their algorithm.

### Algorithm 4.1

(\(\mathsf{DF}\); Dyer, Frieze [10])

**Input**: set

*X*⊆[0,1]

^{2}of

*n*points,

*n*is even.

- 1.
Partition [0,1]

^{2}into*s*=*k*^{2}equal-sized sub-squares \(C_{1},\ldots,C_{k^{2}}\), each of side length 1/*k*, where \(k=\frac{\sqrt{n}}{\log n}\). - 2.
Compute minimum-length perfect matchings for

*X*_{ℓ}for each*ℓ*∈[*k*^{2}]. - 3.
Compute a matching for the unmatched points from the previous step using the strip heuristic [33].

Let \(\mathsf{DF}(X)\) be the cost of the matching computed by the algorithm above on input *X*={*x*_{1},…,*x*_{n}}, and let \(\mathsf{MM}(X)\) be the cost of a perfect matching of minimum total length. Dyer and Frieze showed that \(\mathsf{DF}(X)\) converges to \(\mathsf{MM}(X)\) with probability 1 if the points in *X* are drawn according to the uniform distribution on [0,1]^{2} (this corresponds to Assumption 2.4 with *ϕ*=1). We extend this to the case when *X* is drawn as described in Assumption 2.4.

### 4.1 Smoothed Running-Time

A minimum-length perfect matching can be found in time *O*(*n*^{3}) [1]. By Theorem 3.7, we get the following corollary.

### Corollary 4.2

*Under Assumptions*2.4, 3.2(1),

*and*3.2(2),

*the expected running*-

*time of*\(\mathsf{DF}\)

*on input*

*X*

*is at most*

*If we plug in*\(k = \sqrt{n}/\log n\),

*we obtain an expected running*-

*time of at most*

### 4.2 Smoothed Approximation Ratio

*X*⊆[0,1]

^{2}. This means that

### Lemma 4.3

*Under Assumption*2.4,

*we have*

### Proof

*x*

_{1}is fixed by an adversary and that only

*x*

_{2},…,

*x*

_{n}are drawn independently according to their density functions. Then we obtain The probability that ∥

*x*

_{1}−

*x*

_{i}∥≤

*r*can be bounded from above by

*ϕ*times the area of a circle of radius

*r*, which is

*ϕπr*

^{2}. Thus, The second inequality holds because \(1- \phi\pi r^{2} \geq1-\frac{1}{n}\) for \(r \in[0, 1/\sqrt{\phi\pi n}]\). The third inequality exploits \((1-\frac{1}{n})^{n-1} \geq1/e\). □

*O*(1/

*k*), we can use

Unfortunately, we cannot bound the worst-case approximation ratio of Dyer and Frieze’s partitioning algorithm. Thus, we cannot apply Theorem 3.8, but we have to use Theorem 3.9. Thus, we first need a tail bound for \(1/\mathsf{MM}(X)\). The bound in the following lemma suffices for our purposes.

### Lemma 4.4

*Under Assumption*2.4,

*we have*

*for all*\(c \leq\frac{1}{2\pi}\).

### Proof

*M*has a length of at most

*c*. We let an adversary fix one end-point of each edge. Then the probability that a specific edge of

*M*has a length of at most

*c*is bounded from above by

*ϕπc*

^{2}. Thus, the density of the length of a particular edge is bounded from above by 2

*ϕπc*≤

*ϕ*as \(c \leq\frac{1}{2\pi}\). Furthermore, the lengths of the edges of

*M*are independent random variables. Thus, the probability that the sum of the edge lengths of all

*n*/2 edges of

*M*is bounded from above by

*c*is at most \(\frac{(\phi\pi c)^{n/2}}{(n/2)!}\), which can be proved by the following induction: Let

*m*=

*n*/2, and let

*a*

_{1},…,

*a*

_{m}be the (random) edge lengths of the edge of

*M*. For

*m*=1, the statement follows from \(\mathbb{P}[a_{1} \leq c] \leq\phi c\). For larger

*m*, assume that the claim holds for

*m*−1, and let

*h*be the density of

*a*

_{m}. This density is bounded by

*ϕ*as argued above. Thus,

*n*vertices is (

*n*−1)!!=(

*n*−1)⋅(

*n*−3)⋅(

*n*−5)⋯ (“!!” denotes the double factorial). A union bound over all matchings yields

With this tail bound for \(1/\mathsf{MM}(X)\), we can prove the following bound on the smoothed approximation ratio.

### Corollary 4.5

*Under Assumptions *2.4 *and* 3.2(3), *the expected approximation ratio of*\(\mathsf{DF}\)*is*\(1 + O(\frac{\sqrt{\phi}}{\log n})\).

### Proof

*h*

_{n}(

*x*)=(2

*ϕπx*)

^{n/2}and yields

*n*. Thus, also by Assumption 3.2(3),

*n*.

### Remark 4.6

- 1.
There exist other partitioning schemes for Euclidean matching [2], which can be analyzed in a similar way.

- 2.
Instead of a standard cubic-time algorithm, we can use Varadarajan’s matching algorithm [34] for computing the optimal matchings within each cell. This algorithm has a running-time of

*O*(*m*^{1.5}log^{5}*m*) for*m*points, which improves the running-time bound to \(O(n\sqrt{\phi}\log(n)\log^{5}(\phi\log n))\).

## 5 Karp’s Partitioning Scheme for Euclidean TSP

Karp’s partitioning scheme [18] is a heuristic for Euclidean TSP that computes near-optimal solutions on average. It proceeds as follows:

### Algorithm 5.1

(\(\mathsf{KP}\), Karp’s partitioning scheme)

**Input**: set

*X*⊆[0,1]

^{2}of

*n*points.

- 1.
Partition [0,1]

^{2}into \(k = \sqrt{n/\log n}\) stripes such that each stripe contains exactly \(n/k = \sqrt{n \log n}\) points. - 2.
Partition each stripe into

*k*cells such that each cell contains exactly*n*/*k*^{2}=log*n*points. - 3.
Compute optimal TSP tours for each cell.

- 4.
Join the tours to obtain a TSP tour for

*X*.

We remark that the choice of *k* in Karp’s partitioning scheme is optimal in the following sense: On the one hand, more than *Θ*(log*n*) points per cell would yield a super-polynomial running-time as the running-time is exponential in the number of points per cell. On the other hand, less than *Θ*(log*n*) point per cell would yield a worse approximation ratio as the approximation ratio gets worse with increasing *k*.

For a point set *X*⊆[0,1]^{2}, let \(\mathsf{KP}(X)\) denote the cost of the tour through *X* computed by Karp’s scheme. Steele [31] has proved complete convergence of \(\mathsf {KP}(X)\) to \(\mathsf{TSP}(X)\) with probability 1, if the points are chosen uniformly and independently. Using our framework developed in Sect. 3, we extend the analysis of \(\mathsf{KP}\) to the case of non-uniform and non-identical distributions.

Since Karp’s scheme chooses the cells adaptively based on the point set *X*, our framework for the analysis of the running-time cannot be applied. However, the total running-time of the algorithm is \(T(n)=2^{n/k^{2}} \mathop{\mathrm{poly}}(n/k^{2})+ O(k^{2})\), which is, independent of the randomness, polynomial in *n* for *k*^{2}=*n*/log*n*.

The nice thing about the TSP is that every tour has a worst-case approximation guarantee: Consider any two points *x*,*y*∈*X*. Since any tour must visit both *x* and *y*, its length is at least 2∥*x*−*y*∥ by the triangle inequality. Since a tour consists of *n* edges, any tour has a length of at most \(\frac{n}{2} \cdot\mathsf{TSP}(X)\). Thus, we can use Theorem 3.8 together with *α*(*n*)=*n*/2 and obtain the following result.

### Corollary 5.2

*Under Assumptions *2.4 *and *3.2(3), *the expected approximation ratio of*\(\mathsf{KP}\)*is*\(\mathbb{E}[ \frac{\mathsf{KP}(X)}{\mathsf{TSP}(X)}]\leq 1 +O(\sqrt{\phi/\log n})\).

### Proof

*α*(

*n*)=

*n*/2 into the bound of Theorem 3.8 and obtain an upper bound of

## 6 Euclidean Steiner Trees

Kalpakis and Sherman [17] proposed a partitioning algorithm for the Euclidean minimum Steiner tree problem analogous to Karp’s partitioning scheme for Euclidean TSP. The solution produced by their algorithm converges to the optimal value with probability 1−*o*(1). Also, their algorithm [17] is known to produce near-optimal solutions in practice too [24]. Let us now describe Kalpakis and Sherman’s algorithm [17].

### Algorithm 6.1

(\(\mathsf{KS}\), Kalpakis, Sherman [17])

**Input**: set

*X*⊆[0,1]

^{2}of

*n*points.

- 1.
Let

*s*=*n*/log*n*. Partition [0,1]^{2}into*Θ*(*s*) cells such that each cell contains at most*n*/*s*=log*n*points. - 2.
Solve the Steiner tree problem optimally within each cell.

- 3.
Compute a minimum-length spanning tree to connect the forest thus obtained.

The running-time of this algorithm is polynomial for the choice of *s*=*n*/log*n* [8]. For the same reason as for Karp’s partitioning scheme, we cannot use our framework to estimate the running-time, because the choice of cells depends on the actual point set.

*X*, and let \(\mathsf{MST}(X)\) denote the cost of a minimum-length spanning tree of

*X*. Kalpakis and Sherman [17] have shown that

Since minimum spanning trees are \(2/\sqrt{3}\) approximations for Euclidean Steiner trees [9], we have \(\mathsf{ST}(X) \geq\frac{\sqrt{3}}{2}\cdot\mathsf{MST}(X)\). Furthermore, we have \(\mathsf{MST}(X) \geq\frac{1}{2} \cdot\mathsf{NN}(X)\). Thus, we can choose \(\mu_{\mathsf{ST}}(n,\phi) = \varTheta(\sqrt {n/\phi})\) by Lemma 4.3.

As \(\mathsf{KP}\) for the traveling salesman problem, \(\mathsf{KS}\) comes with a worst-case approximation ratio of *α*(*n*)=*O*(*n*). The reason is that, for any two points *x*,*y*∈*X*, we have \(\|x-y\|\leq\mathsf{ST}(X)\). Since Kalpakis and Sherman’s partitioning algorithm [17] outputs at most a linear number of edges, we have \(\mathsf{KS}(X) \leq O (n \cdot\mathsf {ST}(X) )\). This gives us a worst-case approximation ratio of *O*(*n*) and yields the following corollary of Theorem 3.8.

### Corollary 6.2

*Under Assumptions*2.4

*and*3.2(3),

*the expected approximation ratio of*\(\mathsf{KS}\)

*is*

### Proof

The proof is almost identical to the proof of Corollary 5.2. □

## 7 Degree-Bounded Minimum Spanning Tree

A *b*-degree-bounded minimum spanning tree of a given set of points in [0,1]^{2} is a spanning tree in which the degree of every point is bounded by *b*. For 2≤*b*≤4, this problem is NP-hard, and it is solvable in polynomial time for *b*≥5 [23]. Let \(\mathsf{dbMST}\) denote the Euclidean functional that maps a point set to the length of its shortest *b*-degree-bounded minimum spanning tree.

### Proposition 7.1

\(\mathsf{dbMST}\)*is a smooth*, *sub*-*additive and near*-*additive Euclidean functional*.

### Proof

The smoothness and sub-additivity properties have been proved by Srivastav and Werth [29]. They have also defined a canonical super-additive boundary functional that well-approximates \(\mathsf {dbMST}\) [29, Lemmas 3 and 4]. This, together with Proposition 2.1 proves that \(\mathsf{dbMST}\) is near-additive. □

*b*-degree-bounded minimum spanning tree problem. Let \(\mathsf{P-bMST}\) be the adaptation of Karp’s partitioning algorithm to \(\mathsf{dbMST}\) with parameter \(k^{2}=\frac{n \log\log n}{\log n}\). With this choice of

*k*, \(\mathsf{P-bMST}\) runs in polynomial-time as a degree-bounded minimum-length spanning tree on

*m*nodes can be found in time 2

^{O(mlogm)}using brute-force search. Then, for any

*X*, we have

Again, we have \(\|x-y\| \leq\mathsf{dbMST}(X)\) for all *X* and *x*,*y*∈*X*, which implies that any possible tree is at most a factor *n* worse than the optimal tree. This implies in particular that the worst-case approximation ratio of \(\mathsf{P}\mbox{-}\mathsf{bMST}\) is *O*(*n*): \(\mathsf{P}\mbox{-}\mathsf{bMST}(X) =O(n \cdot \mathsf{dbMST}(X))\). Furthermore, we can use \(\mu_{\mathsf{dbMST}}(n, \phi) = \varOmega (\sqrt{n/\phi})\) by Lemma 4.3 as \(\mathsf{dbMST}(X) = \varOmega(\mathsf{NN}(X))\).

We can apply Theorem 3.8 to obtain the following result.

### Corollary 7.2

*Under Assumptions*2.4

*and*3.2(3),

*the expected approximation ratio is*

### Proof

The proof is almost identical to the proof of Corollary 5.2. The only difference is we now have to use \(J=O(\sqrt{n\log\log n/\log n})\), which leads to the slightly worse bound for the approximation ratio. □

Again, we cannot use our framework for the running-time, but the running-time is guaranteed to be bounded by a polynomial.

## 8 Concluding Remarks

We have provided a smoothed analysis of partitioning algorithms for Euclidean optimization problems. The results can be extended to distributions over \(\mathbb{R}^{2}\) by scaling down the instance so that the inputs lie inside [0,1]^{2}. The analysis can also be extended to higher dimensions. However, the value of *ϕ* for which our results are applicable will depend on the dimension *d*.

Even though solutions computed by most of the partitioning algorithms achieve convergence to the corresponding optimal value with probability 1 under uniform samples, in practice they have constant approximation ratios close to 1 [16, 24]. Our results show that the expected function values computed by partitioning algorithms approach optimality not only under uniform, identical distributions, but also under non-uniform, non-identical distributions, provided that the distributions are not sharply concentrated.

One prominent open problem for which our approach does not work is the functional defined by the total edge weight of a minimum-weight triangulation in the Euclidean plane. The main obstacles for this problem are that, first, the functional corresponding to minimum-weight triangulation is not smooth and, second, the value computed by the partitioning heuristic depends on the number of points in the convex hull of the point set [15]. Damerow and Sohler [7] provide a bound for the smoothed number of points in the convex hull. However, their bound is not strong enough for analyzing triangulations.

### Open Access

This article is distributed under the terms of the Creative Commons Attribution License which permits any use, distribution, and reproduction in any medium, provided the original author(s) and the source are credited.