EditorialBoard LectureNotesinComputerScience6844

(1)

(2)

Lecture Notes in Computer Science 6844

Commenced Publication in 1973 Founding and Former Series Editors:

Gerhard Goos, Juris Hartmanis, and Jan van Leeuwen

Editorial Board

David Hutchison

Lancaster University, UK Takeo Kanade

Carnegie Mellon University, Pittsburgh, PA, USA Josef Kittler

University of Surrey, Guildford, UK Jon M. Kleinberg

Cornell University, Ithaca, NY, USA Alfred Kobsa

University of California, Irvine, CA, USA Friedemann Mattern

ETH Zurich, Switzerland John C. Mitchell

Stanford University, CA, USA Moni Naor

Weizmann Institute of Science, Rehovot, Israel Oscar Nierstrasz

University of Bern, Switzerland C. Pandu Rangan

Indian Institute of Technology, Madras, India Bernhard Steffen

TU Dortmund University, Germany Madhu Sudan

Microsoft Research, Cambridge, MA, USA Demetri Terzopoulos

University of California, Los Angeles, CA, USA Doug Tygar

University of California, Berkeley, CA, USA Gerhard Weikum

Max Planck Institute for Informatics, Saarbruecken, Germany

(3)

(4)

Frank Dehne John Iacono Jörg-Rüdiger Sack (Eds.)

Algorithms

and Data Structures

12th International Symposium, WADS 2011 New York, NY, USA, August 15-17, 2011 Proceedings

1 3

(5)

Volume Editors Frank Dehne

Carleton University, School of Computer Science Parallel Computing and Bioinformatics Laboratory VISM Building, Room 6210, 1125 Colonel By Drive Ottawa, ON K1S 5B6, Canada

E-mail: [email protected] John Iacono

Polytechnic Institute of New York University Department of Computer Science and Engineering 5 MetroTech Center, New York, NY 11201, USA E-mail: [email protected]

Jörg-Rüdiger Sack

Carleton University, School of Computer Science Herzberg Laboratories

Herzberg Building, Room 5350, 1125 Colonel By Drive Ottawa, ON K1S 5B6, Canada

E-mail: [email protected]

ISSN 0302-9743 e-ISSN 1611-3349

ISBN 978-3-642-22299-3 e-ISBN 978-3-642-22300-6 DOI 10.1007/978-3-642-22300-6

Springer Heidelberg Dordrecht London New York Library of Congress Control Number: 2011930928

CR Subject Classification (1998): F.2, E.1, G.2, I.3.5, G.1, C.2

LNCS Sublibrary: SL 1 – Theoretical Computer Science and General Issues

This work is subject to copyright. All rights are reserved, whether the whole or part of the material is concerned, specifically the rights of translation, reprinting, re-use of illustrations, recitation, broadcasting, reproduction on microfilms or in any other way, and storage in data banks. Duplication of this publication or parts thereof is permitted only under the provisions of the German Copyright Law of September 9, 1965, in its current version, and permission for use must always be obtained from Springer. Violations are liable to prosecution under the German Copyright Law.

The use of general descriptive names, registered names, trademarks, etc. in this publication does not imply, even in the absence of a specific statement, that such names are exempt from the relevant protective laws and regulations and therefore free for general use.

Typesetting: Camera-ready by author, data conversion by Scientific Publishing Services, Chennai, India Printed on acid-free paper

Springer is part of Springer Science+Business Media (www.springer.com)

(6)

Preface

This volume contains the papers presented at the 2011 Algorithms and Data Structures Symposium (WADS 2011), formerly Workshop on Algorithms and Data Structures, held during August 15-17, 2011 at the Polytechnic Institute of New York University in Brooklyn, New York. WADS alternates with the Scandinavian Workshop on Algorithms Theory (SWAT), continuing the tradition of SWAT and WADS starting with SWAT 1988 and WADS 1989.

In response to the call for papers, 141 papers were submitted. From these sub- missions, the Program Committee selected 59 papers for presentation at WADS 2011. In addition, invited lectures were given by the following distinguished re- searchers: Janos Pach, Mihai Pˇatra¸scu, and Robert E. Tarjan. The proceedings do not contain an abstract of Mihai Pˇatra¸scu’s invited lecture “Modern Data Structures”, because it was unavailable at the time of printing for health reasons.

We would like to express our appreciation to the Program Committee mem- bers, invited speakers, reviewers, and all authors who submitted papers.

May 2011 Frank Dehne

John Iacono J¨org-R¨udiger Sack

(7)

(8)

Organization

Program Committee

Oswin Aichholzer Graz University of Technology, Austria David Bader Georgia Institute of Technology, USA

Piotr Berman Penn State University, USA

Prosenjit Bose Carleton University, Canada Timothy Chan University of Waterloo, Canada

Otfried Cheong KAIST, Korea

Frank Dehne Carleton University, Canada

Marina Gavrilova University of Calgary, Canada Roberto Grossi University of Pisa, Italy

John Iacono Polytechnic Institute of New York University, USA

Giuseppe Italiano University of Rome “Tor Vergata”, Italy

Naoki Katoh Kyoto University, Japan

Rolf Klein University of Bonn, Germany

Eduardo Sany Laber PUC Rio, Brazil

Mike Langston University of Tennessee, USA Moshe Lewenstein Bar-Ilan University, Israel

M. M¨uller-Hannemann University of Halle-Wittenberg, Germany Joerg-Ruediger Sack Carleton University, Canada

Peter Sanders University of Karlsruhe, Germany Paul Spirakis University of Patras, Greece

Subhash Suri University of California, Santa Barbara, USA

Monique Teillaud INRIA Sophia Antipolis, France Jan Arne Telle University of Bergen, Norway Marc Van Kreveld Utrecht University, The Netherlands

Additional Reviewers

Aloupis, Greg Alt, Helmut

Alves Pessoa, Artur Amir, Amihood Aum¨uller, Martin Bae, Sang Won Battaglia, Giovanni Batz, G. Veit

Bauer, Reinhard Bereg, Sergey Berger, Florian Bodlaender, Hans L.

Bornstein, Claudson Cabello, Sergio Calka, Pierre Caprara, Alberto

(9)

VIII Organization

Castelli Aleardi, Luca Cesati, Marco

Chen, Danny Z.

Cicalese, Ferdinando Cohen-Steiner, David Collette, Sebastien Cozzens, Midge Damaschke, Peter Deberg, Mark Devillers, Olivier Didimo, Walter Disser, Yann Driemel, Anne Durocher, Stephane Dyer, Ramsay Eppstein, David Erdos, Peter L.

Erickson, Jeﬀ Erlebach, Thomas Eyraud-Dubois, Lionel Fagerberg, Rolf Fekete, Sandor Ferreira, Rui Foschini, Luca Foschni, Luca Fotakis, Dimitris Fournier, Herv´e Fukunaga, Takuro Georgiadis, Loukas Ghosh, Arijit

Giannopoulos, Panos Gibson, Matt Gilbers, Alexander Goaoc, Xavier Goldstein, Isaac Golin, Mordecai Grandoni, Fabrizio Gudmundsson, Joachim G¨orke, Robert

Ha, Jae-Soon

Halldorsson, Magnus M.

Har-Peled, Sariel Haverkort, Herman

Henriques Carvalho, Marcelo Hermelin, Danny

Hershberger, John Hoffmann, Michael Hong, Seok-Hee Howat, John Hüffner, Falk Jacobs, Tobias Jørgensen, Allan Kaminski, Marcin Kamiyama, Naoyuki Kaporis, Alexis Kawahara, Jun Keil, Mark Klein, Philip Kobayashi, Yusuke Kobourov, Stephen Kopelowitz, Tsvi Korman, Matias Koutsoupias, Elias Kraschewski, Daniel Kratochvil, Jan Kása, Zoltán Kärkkäinen, Juha Laber, Eduardo Lancichinetti, Andrea Landau, Gad

Langerman, Stefan Langetepe, Elmar Laura, Luigi Lazard, Sylvain Lecroq, Thierry Lee, Mira

Lenchner, Jonathan Leveque, Benjamin Liotta, Giuseppe Lopez-Ortiz, Alejandro Luccio, Fabrizio L¨oﬄer, Maarten M.M. De Castro, Pedro Manthey, Bodo

Manzini, Giovanni Meyerhenke, Henning Michail, Othon Molinaro, Marco Morin, Pat Moruz, Gabriel

(10)

Organization IX

Mulzer, Wolfgang Mumford, Elena M¨akinen, Veli Naswa, Sudhir Navarro, Gonzalo Nekrich, Yakov Nikoletseas, Sotiris N¨ollenburg, Martin Okamoto, Yoshio Orlandi, Alessio Osipov, Vitaly Otachi, Yota

Ottaviano, Giuseppe Pal, Sudebkumar

Panagopoulou, Panagiota Papadopoulos, Fragkiskos Park, Jeong-Hyeon Park, Kunsoo Penninger, Rainer Phillips, Charles Porat, Ely Rabinovich, Yuri Reinbacher, Iris Riedy, Jason Roditty, Liam Romani, Francesco R¨oglin, Heiko Saitoh, Toshiki Sauerwald, Thomas Schlipf, Lena Schulz, Andr´e Schuman, Catherine Serna, Maria

Silveira, Rodrigo Slingsby, Adrian Smorodinsky, Shakhar Sotelo, David

Speckmann, Bettina Stamatiou, Ioannis Stehn, Fabian Sviridenko, Maxim Takaoka, Tadao Takazawa, Kenjiro Tanigawa, Shin-Ichi Tazari, Siamak Thilikos, Dimitrios Tischler, German Toma, Laura T¨aubig, Hanjo Uno, Takeaki Uno, Yushi Vigneron, Antoine Villanger, Yngve Wang, Kai Weihe, Karsten Wiese, Andreas Wilkinson, Bryan Wismath, Steve Wolﬀ, Alexander Wood, David R.

Wulﬀ-Nilsen, Christian Xin, Qin

Yang, Jungwoo Yildiz, Hakan Yvinec, Mariette Zarrabi-Zadeh, Hamid

(11)

(12)

Piecewise-Linear Approximations of Uncertain Functions

Mohammad Ali Abam^1,, Mark de Berg², and Amirali Khosravi^2,

1 Department of Computer Engineering, Sharif University of Technology, Tehran, Iran

[email protected]

2 Department of Mathematics and Computing Science, TU Eindhoven, Eindhoven, The Netherlands

{mdberg,akhosrav}@win.tue.nl

Abstract. We study the problem of approximating a function F :R→ Rby a piecewise-linear function F when the values of F at{x1, . . . , xⁿ} are given by a discrete probability distribution. Thus, for eachxiwe are given a discrete set yî,1, . . . , yî,m_i of possible function values with associated probabilitiespi,jsuch thatPr[F(xi) =yi,j] =pi,j. We define the error of F aserror(F,F) = maxⁿi=1E[|F(xⁱ)−F(xⁱ)|]. Letm=n

i=1mⁱ be the total number of potential values over all F(xi). We obtain the following two results: (i) anO(m) algorithm that, given F and a maximum errorε, computes a function F with the minimum number of links such thaterror(F,F)ε; (ii) anO(n⁴^/³⁺^δ+mlogn) algorithm that, given F, an integer value 1knand anyδ >0, computes a function F of at mostklinks that minimizes error(F,F).

1 Introduction

Motivation and problem statement. Fitting a function to a given finite set of points sampled from an unknown function F : R → R is a basic problem in mathematics. Typically one is given a class of “simple” functions—linear functions, piecewise linear functions, quadratic functions, etcetera—and the goal is to find a function F from that class that fits the sample points best. One way to measure how well F fits the sample points is theuniform metric, defined as follows. Suppose that F is sampled atx1, . . . , xn, withx1<· · ·< xn. Then the error of F according to the uniform metric isn

i=1|F(xi)−F(xi)|. This measure is also known as thel_∞or the Chebychev error measure.

The problem of ﬁnding the best approximation F under the uniform metric has been studied from an algorithmic point of view, in particular for the case where the allowed functions are piecewise linear. There are then two optimization problems that can be considered: the min-kand the min-εproblem. In the min-k

Work by Mohammad Ali Abam was done when he was employed by Technische Universit¨at Dortmund.

Work by Amirali Khosravi has been supported by the Netherlands’ Organisation for Scientiﬁc Research (NWO) under project no. 612.000.631.

F. Dehne, J. Iacono, and J.-R. Sack (Eds.): WADS 2011, LNCS 6844, pp. 1–12, 2011.

c Springer-Verlag Berlin Heidelberg 2011

(19)

2 M. Ali Abam, M. de Berg, and A. Khosravi

problem one is given a maximum errorε0 and the goal is to ﬁnd piecewise- linear function F with error at mostεthat minimizes the number of links. In the min-εproblem one is given a numberk1 and the goal is to ﬁnd a piecewise- linear function with at mostklinks that minimizes the error.

The min-kproblem was solved in O(n) time by Hakimi and Schmeichel [10].

They also gave an O(n²logn) algorithm for solving the min-ε problem. This was later improved toO(n²) by Wanget al.[17]. Goodrich [8] then managed to obtain anO(nlogn) algorithm.

In this paper we also study the problem of approximating a sampled function by a piecewise-linear function, but we do this in the setting where the function values F(x_i) at the sample points are not known exactly. Instead we have a discrete probability distribution for each F(x_i), that is, we have a discrete set y_i,1, . . . , y_i,m_i of possible values with associated probabilities p_i,j such that Pr[F(x_i) =y_i,j] =p_i,j. We call such a function anuncertain function. The goal is now to ﬁnd a piecewise-linear function F with at mostklinks that minimizes the expected error (the min-ε problem) or a piecewise-linear function F with error at mostεthat minimizes the number of links (the min-k problem).

There are several possibilities to deﬁne the expected error. We use the uniform metric and deﬁne our error measure in the following natural way.

error(F,F) = max

E[|F(xi)−F(xi)|] : 1in .

This error is not equal to error2(F,F) = max{|E[F(x_i)]−F(x_i)| : 1 i n}. Indeed, to minimize|E[F(x_i)]−F(x_i)|one should take F(x_i) =E[F(x_i)] leading to an error of zero atx_i. Hence, we feel thaterror(F,F) is more appropriate than error2(F,F). (Note that approximating F under error measureerror2boils down to approximating the functionG:R→RwithG(x_i) =E[F(x_i)].)

Related work. The problem of approximating a sampled function can be seen as a special case of line simplification. The line-simplification problem is to approximate a given polygonal curveP =p1, p2, . . . , pn by a simpler polygonal curve Q=q1, q2, . . . , qk. The problem comes in many flavors, depending on the restric- tions that are put on the approximationQ, and on the error measureerror(P, Q) that defines the quality of the approximation. A typical restriction is that the sequence of vertices ofQ be a subsequence of the vertices of P, with q₁ =p₁ and q_k = p_n; the unrestricted version, where the vertices q₁, q₂, . . . , q_k can be chosen arbitrarily, has been studied as well. (In this paper we do not restrict the locations of the breakpoints of our piecewise-linear function.) Typical error measures are the Hausdorff distance and the Fréchet distance [4].

The line-simplification has been studied extensively. The oldest and probably best-known algorithm for line simplification is the so-called Douglas-Peucker algorithm [7], dating back to 1973. This algorithm achieves good results in practice, but it is not guaranteed to give optimal results. Over the past 20 years or so, algorithms giving optimal results have been developed for many line-simplification variants [1,2,3,6,8,10,11,?,16]. Although both function approximation and line- simplification are well-studied problems, and there has been ample research on uncertain data in other contexts, the problem we study has, to the best of our knowledge, not been studied so far.

(20)

Piecewise-Linear Approximations of Uncertain Functions 3

y y_i,1 y_i,2

E[F(x_i)]

Ei

u_i g_i

ε

y_i,m_i

Fig. 1.The functionEi(y)

Our results. We start by studying the min-k problem. As it turns out, this problem is fairly easily reduced to the problem of computing a minimum-link path that stabs a set of vertical segments. The latter problem can be solved in linear time [10], leading to an algorithm for the min-k problem running in O(m) time, wherem=n

i=1m_i. We then turn our attention to the much more challenging min-ε problem, where we present an algorithm that, for any ﬁxed δ >0, runs inO(n^4/3+δ+mlogn) time. Our algorithm uses similar ideas as the algorithm from Goodrich [8], but it requires several new ingredients to adapt it to the case of uncertain functions. For the important special casek = 1—here we wish to ﬁnd the best linear function to approximate F—we obtain a faster algorithm for the min-εproblem, running in O(mlogm) time.

2 The min-k Problem

We start by studying the properties oferror(F,F). First we deﬁne an error func- tionEi(y) for every valuexi:

Ei(y) =E[|F(x_i)−y|].

Observe that Ei(F(x_i)) is the expected error of F at x_i, and error(F,F) = maxⁿ_i=1Ei(F(xi)). The following lemma shows what Ei(y) looks like. For simplicity we assumeyi,1· · ·yi,m_i for 1in.

Lemma 1. For any i, the function Ei(y) is a convex piecewise-linear function withmi+ 1links.

Proof. To simplify the presentation, deﬁne yi,0 =−∞and yi,m_i+1 = +∞, and we set pi,0 =pi,m_i+1 = 0. Now ﬁx some j with 0 j mi, and consider the y-interval [yi,j, yi,j+1]. Within this interval we have

Ei(y) =E[|F(xi)−y|]

=j

=1p_i,(y−y_i,) +m_i

=j+1p_i,(y_i,−y)

=j

=1p_i,−m_i

=j+1p_i,

·y − j

=1p_i,y_i,−m_i

=j+1p_i,y_i,

=ajy+bj,

(21)

where aj =

j

=1

pi,−

m_i

=j+1

pi, and bj =−

⎛

⎝^j

=1

pi,yi,−

m_i

=j+1

pi,yi,

⎞

⎠.

Hence, Ei(y) is a piecewise-linear function with m_i + 1 links. Moreover, since a₀ = −1 a₁ · · · a_m_i = 1, it indeed is convex. It is not diﬃcult to see that the ﬁrst and last links of Ei, when extended, meet exactly in the point (E[F(x_i)],0); see Fig. 1. (Actually these two links, when extended, form the graph of the function g(y) =|E[F(x_i)]−y|, so they correspond to the error at

x_i as given byerror2.) 2

Now consider the min-kproblem, and letεbe the given bound on the maximum error. Because Ei(y) is a convex function, there exists an interval [u_i, g_i] such that Ei(y) ε if and only if y ∈ [u_i, g_i]; see Fig. 1. The interval [u_i, g_i] can be computed in O(m_i) time. When there exists ani such that [u_i, g_i] is empty, we report that there is no F approximating F within error ε. Otherwise, the problem is reduced to ﬁnding a function F with a minimum number of links stabbing every vertical segmentxi×[ui, gi]. This problem can be solved in linear time [10], leading to the following theorem.

Theorem 1. Let F :R→Rbe an uncertain function whose values are given at n points {x1, . . . , xn} and let m be the total number of possible values at these points. For a given ε, a piecewise-linear functionFwith a minimum number of links such thaterror(F,F)εcan be computed in O(m)time.

Remark 1. Above we computed the intervals [u_i, g_i] inO(m_i) time in a brute- force manner. However, we can also compute the valuesu_i and g_i in O(logm_i) time using binary search. Then, after computing the functionsEi in O(m) time in total, we can construct the segmentsxi×[ui, gi] inO(

ilogmi) =O(nlogm) time. Thus, after O(m) preprocessing, the min-k problem can be solved in O(nlogm) time. This can be used to speed up the algorithm from the next section whenn=o(m/logm). For simplicity we do not consider this improve- ment in the next section.

3 The min-ε Problem

We now turn our attention to the min-εproblem. Letkbe the maximum number of links we are allowed to use in our approximation. For any ε > 0, define K(ε) to be the minimum number of links of any approximation F such that error(F,F)ε. Note that K(ε) can be computed with the algorithm from the previous section. Clearly, ifε1 < ε2 thenK(ε1)K(ε2). Hence, K(ε) is a non- increasing function ofε and K(ε) n. Our goal is now to find the smallest ε such thatK(ε)k. Let’s call this valueε^∗. BecauseK(ε) is non-increasing, the idea is to use a binary search to find ε^∗, with the algorithm from the previous section as decision procedure. Doing this in an efficient manner is not so easy,

(22)

however. We will proceed in several phases, zooming in further and further to the valueε^∗, as explained next.

Our algorithm maintains an active interval I containing ε^∗. Initially I = [0,∞). A basic subroutine is to reﬁneI on the basis of a setSofε-values, whose output is the smallest interval containingε^∗whose endpoints come from the set S ∪ {endpoint ofI}. The subroutineShrinkActiveInterval runs inO(|S|log|S|+ mlog|S|) time.

ShrinkActiveInterval(S,I)

Sort S to get a sorted list ε1 < ε2 < · · · < εh. Add values ε0 = −∞

andεh+1=∞. Do a binary search overε0, . . . , εh+1 to ﬁnd an interval [εj, εj+1] containing ε^∗; here the basic test during the binary search—

namely whether ε^∗ εl, for some εl—is equivalent to testing whether K(ε_l)k; this can be done inO(m) time with the algorithm from the previous section. Finally, returnI ∩[ε_j, ε_j+1].

The first phase. In the previous section we have seen that each error function Eiis a convex piecewise-linear function withmibreakpoints. LetEi={Ei(yi,j) : 1j m_i} denote the set of error-values of the breakpoints ofEi, and letE= E₁∪ · · · ∪E_n. The first phase of our algorithm is to callShrinkActiveInterval(E, [0,∞)) to find two consecutive values ε_j, ε_j+1 ∈ E such that ε_j ε^∗ ε_j+1. Since|E|=m, this takesO(mlogm) time.

Recall that for a given ε, the approximation F has to intersect the segment x_i×[u_i, g_i] in order for the error to be at mostεatx_i. Now imagine increasing εfromε_j to ε_j+1. Then the valuesu_i andg_i change continuously. In fact, since Ei is a convex piecewise-linear function and ε_j and ε_j+1 are consecutive values fromE, the valuesu_i andg_i change linearly, that is, we have

u_i(ε) =a_iε+b_i and g_i(ε) =c_iε+d_i

for constants a_i, b_i, c_i, d_i that can be computed from Ei. As ε increases,u_i de- creases andgi increases—thus ai <0 andci >0—and so the vertical segment xi×[ui, gi] is growing. After the ﬁrst phase we haveI = [εj, εj+1] and the task is to ﬁnd the smallestε∈[εj, εj+1] such that there exists ak-link path stabbing all the segments.

Intermezzo: the case k= 1. We ﬁrst consider the second phase for the special but important case where k = 1. This case can be considered as the problem of ﬁnding a regression line for uncertain points except that our error is not the squared distance. Thus we want to approximate the uncertain function F by a single line :y =ax+b that minimizes the error. The line stabs a segment x_i ×[u_i, g_i] if is above (x_i, u_i) and below (x_i, g_i). In other words, we need ax_i+ba_iε+b_i andax_i+bc_iε+d_i. Hence, the casek= 1 can be handled by solving the following linear program with variablesa, b, ε:

Minimize ε

Subject to xia+b−aiεbi for all 1in xia+b−ciεdi for all 1in

(23)

U() G()

πu() πg() (x₂, g₂())

(x₄, g₄())

(x₆, g₆())

p G()

U()

(a) (b)

Fig. 2.(a) The pathsπu(ε) andπg(ε). (b) The visibility cone ofp.

Since a 3-dimensional linear program can be solved in linear expected time [5], we get the following theorem.

Theorem 2. The line minimizing error(F, )can be computed in O(mlogm) expected time.

The second phase. As mentioned earlier, our algorithm uses ideas from the algorithm that Goodrich [8] developed for the case of certain¹functions. Next we sketch his algorithm and explain the diﬃculties in applying it to our problem.

For a certain function F, the error functionsEi(y) are cones whose bounding lines have slope−1 and +1, respectively. This implies that, using the notation from above, we haveu_i(0) = gi(0), and ai = −1, and ci = 1 for all i. For a givenε, we deﬁneU(ε) to be the polygonal chain (x₁, u₁(ε)), . . . ,(x_n, u_n(ε)) and G(ε) to be the polygonal chain (x₁, g₁(ε)), . . . ,(x_n, g_n(ε)). (NB: The minimum- link path of error at mostεstabbing all segmentsx_i×[u_i, g_i] does not have to stay within the region bounded byU(ε) andG(ε).) Letπ_u(ε) be the Euclidean shortest path from (x1, u1(ε)) to (x_n, u_n(ε)) that is belowG(ε) and aboveU(ε)—

see Fig. 2(a) for an illustration. Similarly, let π_g(ε) be the Euclidean shortest path from (x1, g1(ε)) to (x_n, g_n(ε)) that is belowG(ε) and aboveU(ε). The paths π_u(ε) andπ_g(ε) together form a so-calledhourglass, which we denote byH(ε).

An edgee∈H(ε) is called aninflection edge if one of its endpoints lies onU(ε) and the other one lies onG(ε). Goodrich [8] showed that there is a minimum-link function F with errorε such that each inflection edge is contained in a link of F and in between two links containing inflection edges the function is convex or concave. (In other words, the “zig-zags” of F occur exactly at the inflection edges.)

Goodrich then proceeds by computing all values of ε at which the set of inﬂection edges changes; these are calledgeodesic-critical values ofε. Note that

1 We use the termcertain functionfor a function with exactly one possible value per sample point, that is, when no uncertainty is involved.

(24)

the moments at which an inflection edge changes are exactly the moments at which the hourglassH(ε) changes. The number of geodesic-critical values isO(n) and they can be found inO(nlogn) time [8]. After finding these geodesic-critical values, a binary search is applied to find two consecutive critical valuesεj, εj+1

such that εj ε^∗ εj+1. Then the inﬂection edges that F must contain are known, and from this F can be computed using parametric search.

The main diﬀerence between our setting and the setting of Goodrich is that the points (x_i, u_i(ε))—and, similarly, the points (x_i, g_i(ε))—do not move at the same speed. As a result the basic lemma underlying the eﬃciency of the approach, namely that there are only O(n) geodesic-critical values of ε, no longer holds.

The following lemma shows that the number of such values can actually be quadratic. The proof of the lemma can be found in the full version of the paper.

Lemma 2. There is an instance ofn vertical segmentsxi×[ui(ε), gi(ε)] where the(xi, ui(ε))’s and(xi, gi(ε))’s are moving at constant (but diﬀerent) velocities such that the number of geodesic-critical events isΩ(n²).

The fact that the number of geodesic-critical values of ε is Ω(n²) is not the only problem we face. The other problem is that detecting these events becomes more diﬃcult in our setting. When all points onU(ε) and on G(ε) move with the same speed, then these events occur only when two consecutive edges of πu(ε) become collinear or when two consecutive edges ofπg(ε) become collinear.

When the points have diﬀerent speeds, however, this is no longer the case. In Fig. 2, for example, the hourglassH(ε) can change when (x2, g2(ε)), (x4, g4(ε)) and (x₆, g₆(ε)) become collinear (which could happen when (x₄, g₄(ε)) moves up relatively slowly).

Below we show how to overcome these two hurdles and obtain an algorithm with subquadratic running time.

We start with a useful observation. Let Ψ(ε) be the simple polygon whose boundary consists of the chainsG(ε) andU(ε), and the vertical segmentsx1× [u1(ε), g1(ε)] andxn×[un(ε), gn(ε]). LetG(ε) be the visibility graph ofΨ(ε), that is,G(ε) is the graph whose nodes are the vertices ofΨ(ε) and where two nodes are connected by an edge if the corresponding vertices can see each other insideΨ(ε).

As ε increases and the vertices ofΨ(ε) move,G(ε) can change combinatorially, that is, edges may appear or disappear.

Lemma 3. The visibility graph G(ε) changes O(n²) times asε increases from 0to∞. Moreover, if G(ε)does not change when εis restricted to some interval [ε1, ε2]then H(ε)does not change either when εis in this interval.

Proof.First we observe that any three vertices ofΨ(ε) become collinear at most once, because each vertex moves with constant velocity and has constant x- coordinate. Indeed, three pointsp, q, r are collinear when (py−qy)/(px−qx) = (py −ry)/(px−rx), and when px, qx, rx are constant and py, qy, ry are linear functions ofε, then this equation has one solution (or possibly inﬁnitely many solutions, which means the points are always collinear).

Next we show that every edgee of G, once it disappears, cannot re-appear.

Deﬁne ˜ui = (xi, ui) and ˜gi = (xi, gi). Assume that e = (˜ui,u˜j) for some i, j;

(25)

the case where one or both of the endpoints ofe are onG(ε) is similar. None of the vertices ofG(ε) can stop ˜ui and ˜uj from seeing each other, since all ˜ui’s move down and all ˜gi’s move up. Hence, the only reason for ˜uiand ˜ujto become invisible to each other is that some vertex ˜ul, withi < l < j, crossese. For ˜uiand

˜

uj to become visible again, ˜ulwould have to crosseagain, but this is impossible since ˜ui,u˜j,u˜j can become collinear at most once. It follows that each edge can appear and disappear at most once, and since there areO(n²) edges in total,G changesO(n²) times.

The second part of the lemma immediately follows from the fact that the shortest pathsπ_u(ε) andπ_g(ε) cannot “jump” asεchanges continuously, because shortest paths in a simple polygon are unique. Hence, these shortest paths—and, consequently,H(ε)—can only change whenG(ε) changes. 2 Computing all combinatorial changes of G still results in an algorithm with running timeΩ(n²). Next we show that it suffices to computeO(n^4/3+δ) combinatorial changes ofG in order to find an interval [ε1, ε2] such thatε^∗ ∈[ε1, ε2] and G does not change in this interval. (Recall that ε^∗ denotes the minimum error that can be achieved withklinks, and that we thus wish to find).

Obtaining stable visibility cones. LetI be the active interval resulting from the ﬁrst phase of our algorithm. We now describe an approach to quickly ﬁnd a subset of the events whereG changes, which we can use to further shrinkI.

Let be a vertical line splitting the set of vertices of Ψ into two (roughly) equal-sized subsets. We will concentrate on the visibility edges whose endpoints lie on the diﬀerent sides of; the approach will be applied recursively to deal with the visibility edges lying completely to the right or completely to the left of . For a vertex p of Ψ(ε) we deﬁne σ(p, ε), the visibility cone of p in Ψ(ε), as the cone with apex pthat contains all rays emanating from p that cross a point onthat is visible fromp(withinΨ(ε)). A crucial observation is that for a vertexpto the left ofand a vertexqto the right of, we have that (p, q) is an edge ofG(ε) if and only ifp∈σ(q, ε) andq∈σ(p, ε).

As the vertices ofΨ move,σ(p, ε) changes continuously but its combinatorial description (the vertices deﬁning its sides) changes at discrete times. Notice that the bottom side of σ(p, ε) passes through a vertex of the lower boundary of Ψ(ε) lying to the same side of as p. More precisely, if U(p, ) denotes the set of vertices on the lower boundary of Ψ(ε) that lie between and the vertical line through p, then the lower side of σ(p, ε) is tangent to the upper hull of U(p, )—see Fig. 2(b). Similarly, if G(p, ) denotes the set of vertices on the upper boundary ofΨ(ε) that lie betweenand the vertical line throughp, then the upper side of σ(p, ε) is tangent to the lower hull of G(p, ). The following lemma shows how many times the lower hull changes of a set of points that all move vertically upwards; by symmetry, the lemma also applies to the number of changes to the upper hull of points moving downwards.

Lemma 4. Supposenpoints in the plane move vertically upward, each with its own constant velocity. Then the number of combinatorial changes to the lower hull isO(n). Furthermore, all event times at which the lower hull changes can be computed inO(nlog³n)time.

(26)

Proof. Let{p1, . . . , pn}be the set of points vertically moving upwards with constant velocities, ordered from left to right. Since the points move with constant velocities, any three points become collinear at most once. As in the proof of Lemma 3, this implies that once a point disappears from the lower hull, it cannot re-appear. Hence, the number of changes to the lower hull isO(n).

To compute all event times, we construct a balanced binary tree T storing the points {p₁, . . . , p_n} in its leaves in an ordered manner based on their x- coordinates. At each nodeν ofT, we maintain a kinetic data structure to track lh(ν), the lower hull of the points stored in the subtree rooted atν. Letν_rand ν_lbe the right and left child of nodeν inT. Thenlh(ν) is formed by portions of lh(ν_r) and lh(ν_l) and the common tangent oflh(ν_r) andlh(ν_l). This implies that in order to track all changes to the lower hull of the whole point set, it suffices to track for each nodeν the changes to common tangents oflh(ν_r) and lh(ν_l). We thus maintain for each node ν a certificate that can be used to find out when the tangent changes. This certificate involves at most six points: the two points determining the current tangent and the at most four points (two on lh(νr) and two onlh(νl)) adjacent to these points. The failure times of theO(n) certificates are put into an event queue. When a certificate fails we update the corresponding tangent, and we update the failure time of the certificate (which means updating the event queue). A change atν may propagate upwards in the tree—that is, it may trigger at mostO(logn) changes in ascendants ofν. Hence, handling a certificate failure takesO(log²n) time. Since the number of changes at each node ν is the number of points stored at the subtree rooted at ν, we handle at mostO(nlogn) events in total. Each event takesO(log²n) time, and so we can compute all events inO(nlog³n) time. 2 Our goal is to shrink the active interval I to a smaller interval such that the visibility cones of the points are stable, that is, do not change combinatorially.

Doing this for eachpindividually will still be too slow, however. We therefore proceed as follows.

Recall that we split Ψ into two with a vertical line . Let R be the set of vertices to the right of . We show how to shrink I so that the cones of the points p ∈ R are stable. Below we only consider the top sides of the cones, which pass through a vertex ofG(ε); the bottom sides can be handled similarly.

We construct a binary treeTG,R on the points inG(ε)∩ R, based on theirx- coordinates. For a nodeν, letP(ν) denote its canonical subset, that is,P(ν) denotes the set of points in the subtree ofν. Using Lemma 4 we compute all event times—that is, values ofε—at which the lower hull lh(P(ν)) changes, for each nodeν. This takesO(nlog⁴n) time in total and gives us a setSofO(nlogn) event times. We then call procedureShrinkActiveInterval(S,I) to further shrinkI, tak- ingO(nlog²n+mlogn) time. In the new active interval, none of the maintained lower hulls changes combinatorially. This does not mean, however, that the top sides of the cones are stable. For that we need some more work.

Recall that the top side ofσ(p, ε) is given by the tangent ofptolh(G(p, )), where G(p, ) is the set of points on theG(ε) in betweenpand (with respect to their x-coordinates). The set G(p, ) can be formed fromO(logn) canonical

(27)

subsets in TG,R. Each canonical subset P(ν) gives a candidate tangent for p, namely the tangent fromptolh(P(ν)). Even though the lower hulls,lh(P(ν)), are stable, the tangents frompto the lower hulls are not. Next we describe how to shrink the active interval, so that these tangents become stable, and we have O(logn) stable candidates.

Consider a canonical subsetP(ν) and letp1, . . . , phbe the vertices oflh(P(ν)), ordered from left to right. An important observation is that, asεincreases and the points move, the tangent fromptolh(P(ν)) steps from vertex to vertex along p1, . . . , p_h, either always going forward or always going backwards. (This is true becausepcan become collinear with any lower-hull edge at most once.) We can therefore proceed as follows. For each pointpand each of its canonical subsets, we compute in constant time at what time pand the middle edge of the lower hull of the canonical subset become collinear. Finding the middle edge can be done using binary search, if we store the lower hullslh(P(ν)) as a balanced tree.

Since we havenpoints and each of them is associated withO(logn) canonical subsets, in total we haveO(nlogn) event times. We put these into a setS and callShrinkActiveInterval(S,I). In the new active interval the number of vertices of each lower hull to whichpcan be tangent has halved. We keep on shrinking I recursively, until we are left with an intervalI such that, for eachpand any canonical subset relevant forp, the tangent frompto the lower hull is stable. In total this takesO(nlog²n+mlogn) time.

Note that within I we now haveO(logn) stable candidate tangent lines for each p. We then compute all O(log²n) times at which the candidate tangent lines swap (in their circular order aroundp), collect allO(nlog²n) event times, and callShrinkActiveInterval once more, takingO(nlog³n+mlogn) time.

After this, we are left with an intervalI such that the top side of the cone of eachp∈ R is stable. In a similar way we can make sure that the bottom sides are stable, and that the top and bottom sides of the points to the left ofare stable. We get the following lemma.

Lemma 5. In O(nlog³n+mlogn)time we can shrink the active intervalI so that in the new active interval all the cones deﬁned with respect toare stable.

We denote the set of edges of G crossing by E(). Next we describe a ran- domization algorithm to shrink the active intervalIsuch that in the new active interval, the edges of E() are stable. After this, we recurse on the part of Ψ to the left of and on the part to the right, so that the whole visibility graph becomes stable.

As already mentioned, (p, q) is an edge ofE() if and only if p∈σ(q, ε) and q ∈ σ(p, ε). Thus E() changes when a point p becomes collinear with a side of σ(q, ε) for some q. Without loss of generality we assume p∈ R and q ∈ L. Thus we have a setHof at mostnhalf-lines originating from points inL, where each half-line is speciﬁed by two points ofL, and a set of n/2 points from R, and we want to compute the event times at which a point ofRand a half-line ofHbecome collinear. Again, explicitly enumerating all these event times takes Ω(n²) time, so we have to proceed more carefully. To this end we use a variant

(28)

of random halving [13], which can be made deterministic using the expander approach [12]. We start with a primitive tool which is used in our algorithm.

Lemma 6. For any ε1 and ε₂, and any δ > 0, we can preprocess H and R in O(n^4/3+δ) time into a data structure that allows the following: count in O(n^4/3+δ)time all events (that is, all the times at which a half-line in Hand a point inRbecome collinear) lying in[ε₁, ε₂], and select in O(logn)time one of these events uniformly at random.

Proof. (Sketch) Consider a half-line l ∈ H and a point p ∈ R. They become collinear at a time in [ε1, ε2] if and only if eitherp(ε1) is belowl(ε1) andp(ε2) is abovel(ε2), orp(ε1) is abovel(ε1) and p(ε2) is below l(ε2). Therefore we need a data structure to report for alll∈ H the points ofRlying to a given side of l(ε1) orl(ε2) . We construct a multilevel partition tree over points ofRat times ε1 and ε2 (one level dealing with ε1, the other dealing withε2), each of whose nodes is associated with a canonical subset ofR. The total size of all canonical subsets isO(n^4/3+δ). For a query linel, the query procedure selectsO(n^1/3+δ) pairwise disjoint canonical subsets whose union consists of exactly those points of R at diﬀerent sides of l at times ε1 and ε2. Based on this we create a set of pairs{(Ai, Bi)} with

(|Ai|+|Bi|) = O(n^4/3+δ) whereAi is a subset ofR andB_i is the subset ofHand eachp∈A_i andl∈B_i become collinear at some time in [ε₁, ε₂]. First we select a pair (A_i, B_i) at random, where the probability of selecting (A_i, B_i) is proportional to |A_i| ∗ |B_i|. Then we select an element uniformly at random fromA_i and an element uniformly at random fromB_i.2 Based on Lemma 6 we proceed as follows. LetI= [ε₁, ε₂] be the current active interval. LetN be the number of event times in I; we can determine N using Lemma 6. Then select an event time ε3 uniformly at random from the event times inI, again using Lemma 6, and we either shrinkI to [ε1, ε3] or to [ε3, ε2] inO(m) time. We recursively continue shrinkingI until the set of events inside I isO(n^4/3); the expected number of rounds isO(logn). OnceN =O(n^4/3) we list all event times, and do a regular binary search.

After this we are left with an active interval I such that the set A() of visibility edges crossing is stable. We recurse on both halves of Ψ to get the whole visibility graph stable. Putting everything together we get the following result.

Lemma 7. For anyδ >0inO(n^4/3+δ+mlogm)expected time we can compute an active intervalI containingε^∗ where the visibility graphG(ε) is stable.

As observed before, the fact that the visibility graph is stable during the active intervalI = [ε1, ε2] implies that the set of inflection edges is stable. This means we can compute all inflection edges during this interval by computing in O(n) time the shortest paths πu(ε1) and πg(ε1). Once this has been done, we can proceed in exactly the same way as Goodrich [8] to findε^∗. Givenε^∗we can find ak-link path of errorε^∗ by solving the min-kproblem forε^∗. This leads to our main result.

(29)

Theorem 3. Let F :R→Rbe an uncertain function whose values are given at n points {x1, . . . , xn} and let m be the total number of possible values at these points. For a givenk, and anyδ >0, we can compute inO(n^4/3+δ+mlogn)time a piecewise-linear functionFwith at mostklinks that minimizeserror(F,F)ε.

References

1. Abam, M.A., de Berg, M., Hachenberger, P., Zarei, A.: Streaming Algorithms for Line Simpliﬁcation. Discrete & Computational Geometry 43, 497–515 (2010) 2. Agarwal, P.K., Varadarajan, K.R.: Eﬃcient Algorithms for Approximating Polyg-

onal Chains. In: Chazelle, B., Goodman, J., Pollack, R. (eds.) Discrete & Compu- tational Geometry, vol. 23, pp. 273–291 (2000)

3. Agarwal, P.K., Har-Peled, S., Mustafa, N.H., Wang, Y.: Near-linear Time Approx- imation Algorithms for Curve Simpliﬁcation. Algorithmica 42, 203–219 (2005) 4. Alt, H., Godau, M.: Computing the Fre´echet Distance between Two Polygonal

Curves. International Journal on Computational Geometry and Applications 5, 75–91 (1995)

5. De Berg, M., Cheong, O., Van Kreveld, M., Overmars, M.: Computational Geom- etry: Algorithms and Applications, 3rd edn. Springer, Heidelberg (2008)

6. Chan, W.S., Chin, F.: Approximation of Polygonal Curves with Minimum Number of Line Segments. In: Chazelle, B., Goodman, J., Pollack, R. (eds.) Proc. 3rd Annual Symp. on Alg. and Comp., vol. 650, pp. 378–387 (1992)

7. Douglas, D.H., Peucker, T.K.: Algorithms for the Reduction of the Number of Points Required to Represent a Digitized Line or its Caricature. Canadian Cartog- rapher 10, 112–122 (1973)

8. Goodrich, M.T.: Eﬃcient Piecewise-linear Function Approximation Using the Uni- form Metric. Discrete & Computational Geometry 14, 445–462 (1995)

9. Guibas, L.J., Hershberger, J.E., Mitchell, J.S.B., Snoeyink, J.S.: Approximating Polygons and Subdivisions with Minimum Link Paths. International Journal of Computational Geometry and Applications 3, 383–415 (1993)

10. Hakimi, S.L., Schmeichel, E.F.: Fitting Polygonal Functions to a Set of Points in the Plane. Graph. Models Image Process. 52, 132–136 (1991)

11. Imai, H., Iri, M.: Polygonal Approximations of a Curve-formulations and Algo- rithms. In: Toussaint, G.T. (ed.) Computational Morphology, pp. 71–86 (1988) 12. Katz, M.J., Sharir, M.: An Expander-based Approach to Geometric Optimization.

SIAM J. Comput. 26, 1384–1408 (1997)

13. Matousek, J.: Randomized Optimal Algorithm for Slope Selection. Inform. Process.

Lett. 36, 183–187 (1991)

14. Melkman, A., O’Rourke, J.: On Polygonal Chain Approximation. In: Toussaint, G.T. (ed.) Computational Morphology, pp. 87–95 (1998)

15. Suri, S.: A Linear Time Algorithm for Minimum Link Paths inside a Simple Poly- gon. Comput. Vision Graph. Image Process. 35, 99–110 (1986)

16. Toussaint, G.T.: On the Complexity of Approximating Polygonal Curves in the Plane. In: Proc. Int. Symp. on Robotics and Automation (1985)

17. Wang, D.P., Huang, D.P., Chao, H.S., Lee, R.C.T.: Plane Sweep Algorithms for Polygonal Approximation Problems with Applications. In: Ng, K.W., Balasubra- manian, N.V., Raghavan, P., Chin, F.Y.L. (eds.) ISAAC 1993. LNCS, vol. 762, pp. 515–522. Springer, Heidelberg (1993)