A deterministic algorithm for fitting a step function to a weighted point-set

Abstract

Given a set of n points in the plane, each point having a positive weight,
and an integer k>0, we present an optimal O(n \log n)-time deterministic
algorithm to compute a step function with k steps that minimizes the maximum
weighted vertical distance to the input points. It matches the expected time
bound of the best known randomized algorithm for this problem. Our approach
relies on Cole's improved parametric searching technique.

Full text

Page 1

A deterministic algorithm for fitting a step function to a
weighted point-set
Herv´ e Fournier∗
Antoine Vigneron†
September 7, 2011
Abstract
Given a set of n points in the plane, each point having a positive weight, and an integer
k > 0, we present an optimal O(nlogn)-time deterministic algorithm to compute a step
function with k steps that minimizes the maximum weighted vertical distance to the input
points. It matches the expected time bound of the best known randomized algorithm for
this problem. Our approach relies on Cole’s improved parametric searching technique.
1 Problem formulation and previous works
A function f : R → R is called a k-step function if there exists a real sequence a1< ··· < ak−1
such that the restriction of f to each of the intervals (−∞,a1), [ai,ai+1) and [ak−1,+∞) is
a constant. A weighted point in the plane is a triplet p = (x,y,w) ∈ R3where (x,y) ∈ R2
represents the coordinates of p and w > 0 is a weight associated with p. We use d(p,f) to
denote the weighted vertical distance between p and f: that is, d(p,f) = w · |f(x) − y|. For a
set of weighted points P, we define the distance d(P,f) between P and a step function f as:
d(P,f) = max{d(p,f) | p ∈ P}.
This histogram construction problem is motivated by databases applications, where one
wants to find a compact representation of the dataset that fits into main memory, so as to
optimize query processing [5]. The unweighted version (that is, when wi = 1 for all i) has
been studied extensively, until optimal algorithms were found; see our previous article [4] and
references therein.
The weighted case was first considered by Guha and Shim [5], who gave an O(nlogn +
k2log6n)-time algorithm. Lopez and Mayster [9] gave an O(n2)-time algorithm, which is thus
faster for small values of k. Then Fournier and Vigneron [4] gave an O(nlog4n) algorithm,
which was further improved to O(min(nlog2n,nlogn + k2logn
Wang [2]. Eventually, an optimal randomized O(nlogn)-time algorithm was obtained by Liu [8].
In this note, we present a deterministic counterpart to Liu’s algorithm, which runs in O(nlogn)
time. This time bound is optimal as the unweighted case already requires Ω(nlogn) time [4].
Our approach combines ideas from previous work on this problem [5, 6] with the improved
parametric searching technique by Cole [3].
klognloglogn)) by Chen and
∗´Equipe de Logique Math´ ematique, Institut de Math´ ematiques de Jussieu, Universit´ e Paris Diderot – Paris 7,
France. Email: herve.fournier@logique.jussieu.fr.
†Geometric Modeling and Scientific Visualization Center, King Abdullah University of Science and Technology,
Thuwal 23955-6900, Saudi Arabia. Email: antoine.vigneron@kaust.edu.sa.
1
arXiv:1109.1152v1 [cs.DS] 6 Sep 2011

Page 2

2An optimal deterministic algorithm
We consider an input set of weighted points P = {(xi,yi,wi) | 1 ? i ? n}, and an integer k > 0.
Let ε∗denote the optimal distance from P to a k-step function, that is,
ε∗= min{d(P,f) | f is a k-step function}.
Karras et al. [6] made the following observation:
Lemma 1 Given a set of n weighted points sorted with respect to their x-coordinate, an integer
k > 0 and a real ε > 0, one can decide in time O(n) if ε < ε∗.
The above lemma is obtained by a greedy method, going through the points from left to right
and creating a new step whenever necessary. More than k steps are created along this process
if and only if ε < ε∗. A consequence is that once ε∗is known, an optimal k-step function can
be built in linear time by running this algorithm on ε = ε∗.
A second observation, made by Guha and Shim [5], is the following. The distance of a point
p = (xi,yi,wi) to the constant function c is equal to d(p,c) = wi· |c − yi|. Hence, for a (non
empty) subset Q ⊆ P of the input points, the distance min{d(Q,f) | f is a constant function}
between Q and the closest constant function is given by the minimum y-coordinate of the points
in the region UQdefined as:
?
In other words, the distance between Q and the closest 1-step function is the y-coordinate of the
lowest vertex in the upper envelope UQof the lines with equation y = ±wi(x−yi) corresponding
to the points (xi,yi,wi) ∈ Q. (There is only one lowest vertex as the slopes ±wiare nonzero.)
An immediate consequence is the following. For i ∈ {1,...,n}, let ?2i−1be the line defined
by the equation y = wi(x−yi), and ?2ithe line defined by y = −wi(x−yi). Let L = {?1,...,?2n}.
We denote by A(L) the arrangement of these lines. (See Figure 1.)
Lemma 2 The optimal distance ε∗from a set of weighted points P to a k-step function is the
y-coordinate of a vertex of A(L).
UQ=
(xi,yi,wi)∈Q
{(x,y) | y ? wi· |x − yi|}.
u
O
x
y
Figure 1: The arrangement A(L) and the upper envelope (shaded) of a subset Q ⊂ L (bold).The
y-coordinate of the lowest point u in UQgives the minimum distance from Q to a 1-step function.
The deterministic algorithm presented here will be obtained by performing a search on the
vertices of A(L), calling the decision procedure of Lemma 1 only O(logn) times, and with an
overall extra time O(nlogn). We achieve it by applying Cole’s improved parametric searching
technique [3]:
2

Page 3

Theorem 3 (Cole) Consider the problem of sorting an array A[1,...,n] of size n. Assume
the following two conditions hold:
(i) There is an O(n) time algorithm to test if A[i] ? A[j].
(ii) There exists a linear order ? on the set {(i,j) | 1 ? i < j ? n} such that
(i,j) ? (i?,j?) ⇒
and such that we can decide if (i,j) ? (i?,j?) in O(1) time.
Then, the array A can be sorted in O(nlogn) time.
?A[i] ? A[j] ⇒ A[i?] ? A[j?]?
We briefly explain Cole’s method. Recall that a sorting network [7] for n elements is a
sequence L1,...,Ld, each Libeing a set of comparisons on disjoint inputs in {1,...,n}. On
an input array A[1,...,n], the network operates as follows: for each level p from 1 to d, the
comparisons in Lpare performed in parallel, and the two elements of A corresponding to each
comparison are swapped if they appear in the wrong order. If the sorting network is correct,
the elements of A are output in sorted order after the last level.
The algorithm from Theorem 3 works as follows. First build a sorting network of depth
O(logn) in deterministic O(nlogn) time [1, 10]. During the course of the sorting algorithm,
each comparison in the network is marked with one of the following labels: resolved, active or
inactive. In the beginning, the comparisons at the first level L1 of the network are marked
active, while all others are inactive. The weight 1/4pis assigned to each active node at level p.
Repeat the following until all nodes are resolved:
– Compute the weighted median (im,jm) of all active comparisons with respect to the order
? defined in (ii);
– Decide if A[im] ? A[jm] with the algorithm from (i). This solves a weighted half of the active
comparisons. Swap the corresponding element of A when in the wrong order, and mark
these comparisons as resolved. Mark all inactive comparisons having their two inputs
resolved as active.
It can be proved that at most O(n) nodes are active at any step. Since the weighted median can
be computed in linear time, each step is performed in O(n) time. Moreover, it can be showed
that the algorithm terminates in at most O(logn) steps. So overall, this procedure sorts an
array of size n in O(nlogn) time.
We are now ready to give our algorithm for fitting a step function to a weighted point set:
Theorem 4 Given a set P of n weighted points in the plane and an integer k > 0, a k-step
function f minimizing d(P,f) can be computed in O(nlogn) deterministic time.
Proof:
otherwise. First we sort the points of P with respect to their x-coordinate. Given ε, this allows
to compute θ(ε) in time O(n), using the decision algorithm of Lemma 1.
We denote by π : R2→ R the projection onto y-coordinate axis. Recall the definition of
the lines L = {?1,...,?2n}. For y ∈ R, let ?i(y) be the unique x ∈ R such that (x,y) ∈ ?i; it is
well-defined since no line is parallel to the x-axis. By Lemma 2, it holds that
Let θ : R → {0,1} be the mapping defined by θ(ε) = 0 if ε < ε∗and θ(ε) = 1
ε∗= min{π(v) | v vertex of A(L), θ(π(v)) = 1}.
Although ε∗is not known, we shall sort the set {?i(ε∗) | 1 ? i ? 2n} using Cole’s method.
3

Page 4

Note that L could be of cardinality smaller than 2n if some lines are identical. We discard
identical lines and order them with respect to their order at −∞. That is, L = {?1,...,?m} and
for all 0 < i < m, it holds that ?i(y) < ?i+1(y) when y → −∞. Let us check that conditions (i)
and (ii) of Theorem 3 hold.
Condition (i): Given i < j, we want to decide if ?i(ε∗) ? ?j(ε∗). If lines ?iand ?jare parallel,
the ordering on the lines ensures that ?i(y) < ?j(y) for all y and in particular for ε∗. Otherwise,
we compute y0= π(?i∩ ?j) in time O(1), then decide if y0< ε∗in time O(n) by Lemma 1. If
y0< ε∗, then ?i(ε∗) > ?j(ε∗); otherwise ?i(ε∗) ? ?i(ε∗).
Condition (ii): For i < j, let us define ˜ π(?i,?j) = π(?i∩ ?j) if lines ?iand ?jintersect, and
˜ π(?i,?j) = +∞ otherwise. (Or equivalently ˜ π(?i,?j) = sup{y ∈ R | ?i(y) < ?j(y)}.) Let ? be
the order on the set {(i,j) | 1 ? i < j ? m} defined by:
(i,j) ? (i?,j?) if and only if ˜ π(?i,?j) ? ˜ π(?i?,?j?).
Assume (i,j) ? (i?,j?) and ?i(ε∗) ? ?j(ε∗). (See figure 2.) From the second condition, it holds
y
?i
?j
?i?
?j?
π(?i∩ ?j)
π(?i? ∩ ?j?)
ε∗
Figure 2: A case where (i,j) ? (i?,j?) and ?i(ε∗) ? ?j(ε∗).
that ε∗? ˜ π(?i,?j), then the first condition yields ε∗? ˜ π(?i?,?j?); it follows that ?i?(ε∗) ? ?j?(ε∗).
Moreover, the order ? can obviously be computed in O(1) time.
Hence Theorem 3 allows to compute a permutation σ of {1,...,m} such that
?σ(1)(ε∗) ? ?σ(2)(ε∗) ? ... ? ?σ(m)(ε∗)
in time O(nlogn). By Lemma 2, it holds that ε∗∈ {π(?σ(i)∩ ?σ(i+1)) | 0 < i < m}. After
sorting this set, we perform a binary search using the linear-time decision algorithm, and thus
we compute ε∗in O(nlogn) time. At last, we run the decision algorithm on ε∗, which gives an
optimal k-step function for P.
3Concluding remarks
When the input points are given in unsorted order, our algorithm is optimal by reduction from
sorting [4]. So an intriguing question is whether there exists an o(nlogn)-time algorithm when
the input points are given in sorted order. For instance, in the unweighted case, a linear-time
algorithm exists if the points are sorted according to their x-coordinates [4].
Our algorithm is mainly of theoretical interest, as Cole’s parametric searching technique
relies on a sorting network with O(logn) depth; all known constructions for such networks in-
volve large constants. So it would be interesting to have a practical O(nlogn)-time deterministic
algorithm.
4

Page 5

References
[1] Mikl´ os Ajtai, J´ anos Koml´ os, and Endre Szemer´ edi. Sorting in clogn parallel sets. Combinatorica,
3(1):1–19, 1983.
[2] Danny Z. Chen and Haitao Wang. Approximating points by a piecewise linear function: I. In
ISAAC, pages 224–233, 2009.
[3] Richard Cole.
34(1):200–208, 1987.
Slowing down sorting networks to obtain faster sorting algorithms.J. ACM,
[4] Herv´ e Fournier and Antoine Vigneron. Fitting a step function to a point set. Algorithmica, 60(1):95–
109, 2011.
[5] Sudipto Guha and Kyuseok Shim. A note on linear time algorithms for maximum error histograms.
IEEE Trans. Knowl. Data Eng., 19(7):993–997, 2007.
[6] Panagiotis Karras, Dimitris Sacharidis, and Nikos Mamoulis. Exploiting duality in summarization
with deterministic guarantees. In KDD, pages 380–389, 2007.
[7] Donald E. Knuth. Sorting and Searching, volume 3 of The Art of Computer Programming. Addison-
Wesley Professional, May 1998.
[8] Jin-Yi Liu. A randomized algorithm for weighted approximation of points by a step function. In
COCOA (1), pages 300–308, 2010.
[9] Mario A. Lopez and Yan Mayster. Weighted rectilinear approximation of points in the plane. In
LATIN, pages 642–653, 2008.
[10] Mike Paterson. Improved sorting networks with O(logN) depth. Algorithmica, 5(1):65–92, 1990.
5