Efficient Nearest-Neighbor Query and Clustering of Planar Curves

TL;DR

This paper introduces efficient algorithms and data structures for nearest-neighbor and center problems involving planar curves, focusing on practical bounds for specific cases and using discrete Frechet distance under different metrics.

Contribution

It provides near-linear and polynomial-time algorithms for nearest-neighbor and center problems for certain curve classes, improving practical applicability and handling translation invariance.

Findings

Practical bounds achieved for line segment cases

Exact algorithms for center problem under $L_ ext{infty}$

Approximate solutions under $L_2$ with near-linear and polynomial time

Abstract

We study two fundamental problems dealing with curves in the plane, namely, the nearest-neighbor problem and the center problem. Let $\mathcal{C}$ be a set of $n$ polygonal curves, each of size $m$. In the nearest-neighbor problem, the goal is to construct a compact data structure over $\mathcal{C}$, such that, given a query curve $Q$, one can efficiently find the curve in $\mathcal{C}$ closest to $Q$. In the center problem, the goal is to find a curve $Q$, such that the maximum distance between $Q$ and the curves in $\mathcal{C}$ is minimized. We use the well-known discrete Frechet distance function, both under~$L_\infty$ and under $L_2$, to measure the distance between two curves. For the nearest-neighbor problem, despite discouraging previous results, we identify two important cases for which it is possible to obtain practical bounds, even when $m$ and $n$ are large. In these cases, either $Q$ is a line segment or $\mathcal{C}$ consists of line segments, and the bounds on the size of the data structure and query time are nearly linear in the size of the input and query curve, respectively. The returned answer is either exact under $L_\infty$, or approximated to within a factor of $1+\varepsilon$ under~$L_2$. We also consider the variants in which the location of the input curves is only fixed up to translation, and obtain similar bounds, under $L_\infty$. As for the center problem, we study the case where the center is a line segment, i.e., we seek the line segment that represents the given set as well as possible. We present near-linear time exact algorithms under $L_\infty$, even when the location of the input curves is only fixed up to translation. Under $L_2$, we present a roughly $O(n^2m^3)$-time exact algorithm.

Figures

Tables

	Input/query:	Input/query:	Input:
	$m$-curves/segment	segments/$m$-curve	(1,2)-center
$L_{\infty }$	Section 3.1 (Section 4.1)	Section 3.2 (Section 4.2)	Section 6.1 (Section 6.2)
$L_2$	Section 5.1	Section 5.2	Section 6.3

Equations

$$d_{dF}^d(C,C^{\prime })=\underset{\tau \in \mathcal{T}}{\min }\underset{(i,j)\in \tau }{\max }d(p_i,q_j),$$

$$1+\sum_{i=2}^{\lceil\log(\beta/\alpha)\rceil}\big{(}\lambda_{i}/\frac{\varepsilon\lambda_{i}}{2\sqrt{2}}\big{)}^{2}=O((1/\varepsilon)^{2}\lceil\log(\beta/\alpha)\rceil).$$

$$d_{dF}(ab,C_j)\le d_{dF}(ab,pq)+d_{dF}(pq,C_j)\le d_{dF}(ab,pq)+d_{dF}(c_g{c}_h,C_i)$$

$$\le \frac{\epsilon }{2}r+(1+\frac{\epsilon }{2})r=(1+\epsilon )r.$$

$$r_{i}^{j}:=\frac{1}{2}\min\left\{\begin{array}[]{lr}\operatorname{\mathit{\delta_{x}}}(C_{j}[1,i]),\operatorname{\mathit{\delta_{x}}}(C_{j}[i+1,m]),(\delta_{x}^{*}-(\min_{v\in C[i+1,m]}v.x-\max_{v\in C[1,i]}v.x))/2,\\ \operatorname{\mathit{\delta_{y}}}(C_{j}[1,i]),\operatorname{\mathit{\delta_{y}}}(C_{j}[i+1,m]),(\delta_{y}^{*}-(\min_{v\in C[i+1,m]}v.y-\max_{v\in C[1,i]}v.y))/2\end{array}\right\}.$$

Full text

For the nearest-neighbor problem, despite discouraging previous results, we identify two important cases for which it is possible to obtain practical bounds, even when $m$ and $n$ are large. In these cases, either $Q$ is a line segment or $\mathcal{C}$ consists of line segments, and the bounds on the size of the data structure and query time are nearly linear in the size of the input and query curve, respectively. The returned answer is either exact under $L_{\infty}$, or approximated to within a factor of $1+\varepsilon$ under $L_{2}$. We also consider the variants in which the location of the input curves is only fixed up to translation, and obtain similar bounds, under $L_{\infty}$.

As for the center problem, we study the case where the center is a line segment, i.e., we seek the line segment that represents the given set as well as possible. We present near-linear time exact algorithms under $L_{\infty}$, even when the location of the input curves is only fixed up to translation. Under $L_{2}$, we present a roughly $O(n^{2}m^{3})$-time exact algorithm.

1 Introduction

We consider efficient algorithms for two fundamental data-mining problems for sets of polygonal curves in the plane: nearest-neighbor query and clustering. Both of these problems have been studied extensively and bounds on the running time and storage consumption have been obtained. In general, these bounds suggest that the existence of algorithms that can efficiently process large datasets of curves of high complexity is unlikely. Therefore we study special cases of the problems where some curves are assumed to be directed line segments (henceforth referred to as segments), and the distance metric is the discrete Fréchet distance.

Such analysis of curves has many practical applications, where the position of an object as it changes over time is recorded as a sequence of readings from a sensor to generate a trajectory. For example, the location readings from GPS devices attached to migrating animals [ABB*+*14], the traces of players during a football match captured by a computer vision system [GH17], or stock market prices [NW13]. In each case, the output is an ordered sequence $C$ of $m$ vertices (i.e., the sensor readings), and by interpolating the location between each pair of vertices as a segment, a polygonal chain is obtained.

Given a collection $\mathcal{C}$ of $n$ curves, a natural question to ask is whether it is possible to preprocess $\mathcal{C}$ into a data structure so that the nearest curve in the collection to a query curve $Q$ can be determined efficiently. This is the nearest-neighbor problem for curves (NNC).

Indyk [Ind02] gave a near-neighbor data structure for polygonal curves under the discrete Fréchet distance. The data structure achieves an approximation factor of $O(\log m+\log\log n)$, where $n$ is the number of curves and $m$ is the maximum size of a curve. Its space consumption is very high, $O(|X|^{\sqrt{m}}(m^{\sqrt{m}}n)^{2})$, where $|X|$ is the size of the domain on which the curves are defined, and the query time is $O(m^{O(1)}\log n)$.

Later, Driemel and Silvestri [DS17] presented a locality-sensitive-hashing scheme for curves under the discrete Fréchet distance, improving the result of Indyk for short curves. They also provide a trade-off between approximation quality and computational performance: for a parameter $k\in[m]$, a data structure using $O(2^{2k}m^{k-1}n\log n+mn)$ space is constructed that answers queries in $O(2^{2k}m^{k}\log n)$ time with an approximation factor of $O(m/k)$.

Recently, Emiris and Psarros [EP18] presented near-neighbor data structures for curves under both discrete Fréchet and dynamic time warping distance. Their algorithm achieves approximation factor of $1+\varepsilon$, at the expense of increasing space usage and preprocessing time. For curves in the plane, the space used by their data structure is $\tilde{O}(n)\cdot(2+\frac{1}{\log m})^{O(m^{1/\varepsilon}\cdot\log(1/\varepsilon))}$ for discrete Fréchet distance and $\tilde{O}(n)\cdot O(\frac{1}{\varepsilon})^{m}$ for dynamic time warping distance, while the query time in both cases is $O(2^{2m}\log n)$.

De Berg et al. [dBGM17] described a dynamic data structure for approximate nearest neighbor for curves (which can also be used for other types of queries such as approximate range searching), under the (continuous) Fréchet distance. Their data structure uses $n\cdot O\left(\frac{1}{\varepsilon}\right)^{2m}$ space and has $O(1)$ query time (for a segment query), but with an additive error of $\varepsilon\cdot reach(Q)$, where $reach(Q)$ is the maximum distance between the start vertex of the query curve $Q$ and any other vertex of $Q$. Furthermore, when the distance from $Q$ to its nearest neighbor is relatively large, the query procedure might fail.

Afshani and Driemel [AD18] studied range searching under both the discrete and continuous Fréchet distance. In this problem, the goal is to preprocess $\mathcal{C}$ such that, given a query curve $Q$ of length $m_{q}$ and a radius $r$, all curves in $\mathcal{C}$ that are within distance $r$ of $Q$ can be found efficiently. For the discrete Fréchet distance in the plane, their data structure uses space in $O(n(\log\log n)^{m-1})$ and has query time in $O(\sqrt{n}\cdot\log^{O(m)}n\cdot m_{q}^{O(1)})$, assuming $m_{q}=\log^{O(1)}n$. They also show that any data structure in the pointer model that achieves $Q(n)+O(k)$ query time, where $k$ is the output size, has to use roughly $\Omega(n/Q(n))^{2})$ space in the worst case, even if queries are just points, for discrete Fréchet distance!

De Berg, Cook, and Gudmundsson [dBCG13] considered range counting queries for curves under the continuous Fréchet distance. Given a single polygonal curve $C$ with $m$ vertices, they show how to preprocess it into a data structure in $O(k\operatorname{\mathrm{polylog}}m)$ time and space, so that, given a query segment $s$, one can return a constant approximation of the number of subcurves of $C$ that lie within distance $r$ of $s$ in $O(\frac{n}{\sqrt{k}}\operatorname{\mathrm{polylog}}m)$ time, where $k$ is a parameter between $m$ and $m^{2}$.

Driemel and Har-Peled [DHP12] preprocess a curve $C$ into a data structure of linear size, which, given a query segment $s$ and a subcurve of $C$, returns a $(1+\varepsilon)$-approximation of the distance between $s$ and the subcurve in logarithmic time.

Clustering is another fundamental problem in data analysis that aims to partition an input collection of curves into clusters where the curves within each cluster are similar in some sense, and a variety of formulations have been proposed [ACMLM03, CL07, DKS16]. The $k$-Center problem [Gon85, AP02, HN79] is a classical problem in which a point set in a metric space is clustered. The problem is defined as follows: given a set $\mathcal{P}$ of $n$ points, find a set $\mathcal{G}$ of $k$ center points, such that the maximum distance from a point in $\mathcal{P}$ to a nearest point in $\mathcal{G}$ is minimized.

Given an appropriate metric for curves, such as the discrete Fréchet distance, one can define a metric space on the space of curves and then use a known algorithm for point clustering. The clustering obtained by the $k$-Center problem is useful in that it groups similar curves together, thus uncovering a structure in the collection, and furthermore the center curves are of value as each can be viewed as a representative or exemplar of its cluster, and so the center curves are a compact summary of the collection. However, an issue with this formulation, when applied to curves, is that the optimal center curves may be noisy, i.e., the size of such a curve may be linear in the total number of vertices in its cluster, see [DKS16] for a detailed description. This can significantly reduce the utility of the centers as a method of summarizing the collection, as the centers should ideally be of low complexity. To address this issue, Driemel et al. [DKS16] introduced the $(k,\ell)$-Center problem, where the $k$ desired center curves are limited to at most $\ell$ vertices each.

Inherent in both problems is a notion of similarity between pairs of curves, which is expressed as a distance function. Several such functions have been proposed to compare curves, including the continuous [Fré06, AG95] and discrete [EM94] Fréchet distance, the Hausdorff distance [Hau27], and dynamic time warping [BC94]. We consider the problems under the discrete Fréchet distance, which is often informally described by two frogs, each hopping from vertex to vertex along a polygonal curve. At each step, one or both of the frogs may advance to the next vertex on its curve, and then the distance between them is measured using some point metric. The discrete Fréchet distance is defined as the smallest maximum distance between the frogs that can be achieved in such a joint sequence of hops of the frogs. The point metrics that we consider are the $L_{\infty}$ and $L_{2}$ metrics. The problem of computing the Fréchet distance has been widely investigated [Bri14, BM16, AAKS14], and in particular Bringmann and Mulzer [Bri14] showed that strongly subquadratic algorithms for the discrete Fréchet distance are unlikely to exist.

Several hardness of approximation results for both the NNC and $(k,\ell)$-Center problems are known. For the NNC problem under the discrete Fréchet distance, no data structure exists requiring $O(n^{2-\varepsilon}\operatorname{\mathrm{polylog}}{m})$ preprocessing and $O(n^{1-\varepsilon}\operatorname{\mathrm{polylog}}{m})$ query time for $\varepsilon>0$, and achieving an approximation factor of $c<3$, unless the strong exponential time hypothesis fails [IM04, DKS16]. In the case of the $(k,\ell)$-Center problem under the discrete Fréchet distance, Driemel et al. showed that the problem is $\mathsf{NP}$-hard to approximate within a factor of $2-\varepsilon$ when $k$ is part of the input, even if $\ell=2$ and $d=1$. Furthermore, the problem is $\mathsf{NP}$-hard to approximate within a factor $2-\varepsilon$ when $\ell$ is part of the input, even if $k=2$ and $d=1$, and when $d=2$ the inapproximability bound is $3\sin{\pi/3}\approx 2.598$ [BDG*+*19].

However, we are interested in algorithms that can process large inputs, i.e., where $n$ and/or $m$ are large, which suggests that the processing time ought to be near-linear in $nm$ and the query time for NNC queries should be near-linear in $m$ only. The above results imply that algorithms for the NNC and $(k,\ell)$-Center problems that achieve such running times are not realistic. Moreover, given that strongly subquadratic algorithms for computing the discrete Fréchet distance are unlikely to exist, an algorithm that must compute pairwise distances explicitly will incur a roughly $O(m^{2})$ running time. To circumvent these constraints, we focus on specific important settings: for the NNC problem, either the query curve is assumed to be a segment or the input curves are segments; and for the $(k,\ell)$-Center problem the center is a segment and $k=1$, i.e., we focus on the $(1,2)$-Center problem.

While these restricted settings are of theoretical interest, they also have a practical motivation when the inputs are trajectories of objects moving through space, such as migrating birds. A segment $ab$ can be considered a trip from a starting point $a$ to a destination $b$. Given a set of trajectories that travel from point to point in a noisy manner, we may wish to find the trajectory that most closely follows a direct path from $a$ to $b$, which is the NNC problem with a segment query. Conversely, given an input of (directed) segments and a query trajectory, the NNC problem would identify the segment (the simplest possible trajectory, in a sense) that the query trajectory most closely resembles. In the case of the $(1,2)$-Center problem, the obtained segment center for an input of trajectories would similarly represent the summary direction of the input, and the radius $r^{*}$ of the solution would be a measure of the maximum deviation from that direction for the collection.

Our results.

We present algorithms for a variety of settings (summarized in the table below) that achieve the desired running time and storage bounds. Under the $L_{\infty}$ metric, we give exact algorithms for the NNC and $(1,2)$-Center problems, including under translation, that achieve the roughly linear bounds. For the $L_{2}$ metric, $(1+\varepsilon)$-approximation algorithms with near-linear running times are given for the NNC problem, and for the $(1,2)$-Center problem, an exact algorithm is given whose running time is roughly $O(n^{2}m^{3})$ and whose space requirement is quadratic. (Parentheses point to results under translation.)

2 Preliminaries

The discrete Fréchet distance is a measure of similarity between two curves, defined as follows. Consider the curves $C=(p_{1},\dotsc,p_{m})$ and $C^{\prime}=(q_{1},\dotsc,q_{m^{\prime}})$, viewed as sequences of vertices. A (monotone) alignment of the two curves is a sequence $\tau:=\langle(p_{i_{1}},q_{j_{1}}),\dotsc,(p_{i_{v}},q_{j_{v}})\rangle$ of pairs of vertices, one from each curve, with $(i_{1},j_{1})=(1,1)$ and $(i_{v},j_{v})=(m,m^{\prime})$. Moreover, for each pair $(i_{u},j_{u})$, $1<u\leq v$, one of the following holds: (i) $i_{u}=i_{u-1}$ and $j_{u}=j_{u-1}+1$, (ii) $i_{u}=i_{u-1}+1$ and $j_{u}=j_{u-1}$, or (iii) $i_{u}=i_{u-1}+1$ and $j_{u}=j_{u-1}+1$. The discrete Fréchet distance is defined as

[TABLE]

with the minimum taken over the set $\mathcal{T}$ of all such alignments $\tau$, and where $d$ denotes the metric used for measuring interpoint distances.

We now give two alternative, equivalent definitions of the discrete Fréchet distance between a segment $s=ab$ and a polygonal curve $C=(p_{1},\dotsc,p_{m})$ (we will drop the point metric $d$ from the notation, where it is clear from the context). Let $C[i,j]:=\{p_{i},\dotsc,p_{j}\}$. Denote by $B(p,r)$ the ball of radius $r$ centered at $p$, in metric $d$. The discrete Fréchet distance between $s$ and $C$ is at most $r$, if and only if there exists a partition of $C$ into a prefix $C[1,i]$ and a suffix $C[i+1,m]$, such that $B(a,r)$ contains $C[1,i]$ and $B(b,r)$ contains $C[i+1,m]$.

A second equivalent definition is as follows. Consider the intersections of balls around the points of $C$. Set $I_{i}(r)=B(p_{1},r)\cap\cdots\cap B(p_{i},r)$ and $\overline{I}_{i}(r)=B(p_{i+1},r)\cap\cdots\cap B(p_{m},r)$, for $i=1,\dotsc,m-1$. Then, the discrete Fréchet distance between $s$ and $C$ is at most $r$, if and only if there exists an index $1\leq i\leq m-1$ such that $a\in I_{i}(r)$ and $b\in\overline{I}_{i}(r)$.

Given a set $\mathcal{C}=\{C_{1},\ldots,C_{n}\}$ of $n$ polygonal curves in the plane, the nearest-neighbor problem for curves is formulated as follows:

Problem 1** (NNC).**

Preprocess $\mathcal{C}$ into a data structure, which, given a query curve $Q$, returns a curve $C\in\mathcal{C}$ with $d_{dF}(Q,C)=\min_{C_{i}\in\mathcal{C}}d_{dF}(Q,C_{i})$.

We consider two variants of 1: (i) when the query curve $Q$ is a segment, and (ii) when the input $\mathcal{C}$ is a set of segments.

Secondly, we consider a particular case of the $(k,\ell)$-Center problem for curves [DKS16].

Problem 2** ($(1,2)$-Center).**

Find a segment $s^{*}$ that minimizes $\max_{C_{i}\in\mathcal{C}}d_{dF}(s,C_{i})$, over all segments $s$.

3 NNC and $L_{\infty}$ metric

When $d$ is the $L_{\infty}$ metric, each ball $B(p_{i},r)$ is a square. Denote by $S(p,d)$ the axis-parallel square of radius $d$ centered at $p$.

Given a curve $C=(p_{1},\ldots,p_{m})$, let $d_{i}$, for $i=1,\ldots,m-1$, be the smallest radius such that $S(p_{1},d_{i})\cap\cdots\cap S(p_{i},d_{i})\neq\emptyset$. In other words, $d_{i}$ is the radius of the smallest enclosing square of $C[1,i]$. Similarly, let $\overline{d}_{i}$, for $i=1,\ldots,m-1$, be the smallest radius such that $S(p_{i+1},\overline{d}_{i})\cap\cdots\cap S(p_{m},\overline{d}_{i})\neq\emptyset$.

For any $d>d_{i}$, $S(p_{1},d)\cap\cdots\cap S(p_{i},d)$ is a rectangle, $R_{i}=R_{i}(d)$, defined by four sides of the squares $S(p_{1},d),\ldots,S(p_{i},d)$, see Figure 1. These sides are fixed and do not depend on the specific value of $d$. Furthermore, the left, right, bottom and top sides of $R_{i}(d)$ are provided by the sides corresponding to the right-, left-, top- and bottom-most vertices in $C[1,i]$, respectively, i.e., the sides corresponding to the vertices defining the bounding box of $C[1,i]$.

Denote by $p^{i}_{\ell}$ the vertex in the $i$th prefix of $C$ that contributes the left side to $R_{i}(d)$, i.e., the left side of $S(p^{i}_{\ell},d)$ defines the left side of $R_{i}(d)$. Furthermore, denote by $p^{i}_{r}$, $p^{i}_{b}$, and $p^{i}_{t}$ the vertices of the $i$th prefix of $C$ that contribute the right, bottom, and top sides to $R_{i}(d)$, respectively. Similarly, for any $d>\overline{d}_{i}$, we denote the four vertices of the $i$th suffix of $C$ that contribute the four sides of the rectangle $\overline{R}_{i}(d)=S(p_{i+1},d)\cap\cdots\cap S(p_{m},d)$ by $\overline{p}^{i}_{\ell}$, $\overline{p}^{i}_{r}$, $\overline{p}^{i}_{b}$, and $\overline{p}^{i}_{t}$, respectively.

Finally, we use the notation $R^{j}_{i}=R^{j}_{i}(d)$ ($\overline{R}^{j}_{i}=\overline{R}^{j}_{i}(d)$) to refer to the rectangle $R_{i}=R_{i}(d)$ ($\overline{R}_{i}=\overline{R}_{i}(d)$) of curve $C_{j}$.

Observation 3**.**

Let $s=ab$ be a segment, $C$ be a curve, and let $d>0$. Then, $d_{dF}(s,C)\leq d$ if and only if there exists $i$, $1\leq i\leq m-1$, such that $a\in R_{i}(d)$ and $b\in\overline{R}_{i}(d)$.

3.1 Query is a segment

Let $\mathcal{C}=\{C_{1},\dotsc,C_{n}\}$ be the input curves, each of size $m$. Given a query segment $s=ab$, the task is to find a curve $C\in\mathcal{C}$ such that $d_{dF}(s,C)=\min_{C^{\prime}\in\mathcal{C}}d_{dF}(s,C^{\prime})$.

The data structure.

The data structure is an eight-level search tree. The first level of the data structure is a search tree for the $x$-coordinates of the vertices $p^{i}_{\ell}$, over all curves $C\in\mathcal{C}$, corresponding to the $nm$ left sides of the $nm$ rectangles $R_{i}(d)$. The second level corresponds to the $nm$ right sides of the rectangles $R_{i}(d)$, over all curves $C\in\mathcal{C}$. That is, for each node $u$ in the first level, we construct a search tree for the subset of $x$-coordinates of vertices $p^{i}_{r}$ which corresponds to the canonical set of $u$. Levels three and four of the data structure correspond to the bottom and top sides, respectively, of the rectangles $R_{i}(d)$, over all curves $C\in\mathcal{C}$, and they are constructed using the $y$-coordinates of the vertices $p^{i}_{b}$ and the $y$-coordinates of the vertices $p^{i}_{t}$, respectively. The fifth level is constructed as follows. For each node $u$ in the fourth level, we construct a search tree for the subset of $x$-coordinates of vertices $\overline{p}^{i}_{\ell}$ which corresponds to the canonical set of $u$; that is, if the $y$-coordinate of $p^{j}_{t}$ is in $u$’s canonical subset, then the $x$-coordinate of $\overline{p}^{j}_{\ell}$ is in the subset corresponding to $u$’s canonical set. The bottom four levels correspond to the four sides of the rectangles $\overline{R}_{i}(d)$ and are built using the $x$-coordinates of the vertices $\overline{p}^{i}_{\ell}$, the $x$-coordinates of the vertices $\overline{p}^{i}_{r}$, the $y$-coordinates of the vertices $\overline{p}^{i}_{b}$, and the $y$-coordinates of the vertices $\overline{p}^{i}_{t}$, respectively.

The query algorithm.

Given a segment $s=ab$ and a distance $d>0$, we can use our data structure to determine whether there exists a curve $C\in\mathcal{C}$, such that $d_{dF}(s,C)\leq d$. The search in the first and second levels of the data structure is done with $a.x$, the $x$-coordinate of $a$, in the third and fourth levels with $a.y$, in the fifth and sixth levels with $b.x$ and in the last two levels with $b.y$. When searching in the first level, instead of performing a comparison between $a.x$ and the value $v$ that is stored in the current node (which is an $x$-coordinate of some vertex $p^{i}_{\ell}$), we determine whether $a.x\geq v-d$. Similarly, when searching in the second level, at each node that we visit we determine whether $a.x\leq v+d$, where $v$ is the value that is stored in the node, etc.

Notice that if we store the list of curves that are represented in the canonical subset of each node in the bottom (i.e., eighth) level of the structure, then curves whose distance from $s$ is at most $d$ may also be reported in additional time roughly linear in their number.

Finding the closest curve.

Let $s=ab$ be a segment, let $C$ be the curve in $\mathcal{C}$ that is closest to $s$ and set $d^{*}=d_{dF}(s,C)$. Then, there exists $1\leq i\leq m-1$, such that $a\in R_{i}(d^{*})$ and $b\in\overline{R}_{i}(d^{*})$. Moreover, one of the endpoints $a$ or $b$ lies on the boundary of its rectangle, since, otherwise, we could shrink the rectangles without ‘losing’ the endpoints. Assume without loss of generality that $a$ lies on the left side of $R_{i}(d^{*})$. Then, the difference between the $x$-coordinate of the vertex $p^{i}_{\ell}$ and $a.x$ is exactly $d^{*}$. This implies that we can find $d^{*}$ by performing a binary search in the set of all $x$-coordinates of vertices of curves in $\mathcal{C}$. In each step of the binary search, we need to determine whether $d\geq d^{*}$, where $d=v-a.x$ and $v$ is the current $x$-coordinate, and our goal is to find the smallest such $d$ for which the answer is still yes. We resolve a comparison by calling our data structure with the appropriate distance $d$. Since we do not know which of the two endpoints, $a$ or $b$, lies on the boundary of its rectangle and on which of its sides, we perform 8 binary searches, where each search returns a candidate distance. Finally, the smallest among these 8 candidate distances is the desired $d^{*}$.

In other words, we perform 4 binary searches in the set of all $x$-coordinates of vertices of curves in $\mathcal{C}$. In the first we search for the smallest distance among the distances $d_{\ell}=v-a.x$ for which there exists a curve at distance at most $d_{\ell}$ from $s$; in the second we search for the smallest distance $d_{r}=a.x-v$ for which there exists a curve at distance at most $d_{r}$ from $s$; in the third we search for the smallest distance $\overline{d}_{\ell}=v-b.x$ for which there exists a curve at distance at most $\overline{d}_{\ell}$ from $s$; and in the fourth we search for the smallest distance $\overline{d}_{r}=b.x-v$ for which there exists a curve at distance at most $\overline{d}_{r}$ from $s$. We also perform 4 binary searches in the set of all $y$-coordinates of vertices of curves in $\mathcal{C}$, obtaining the candidates $d_{b}$, $d_{t}$, $\overline{d}_{b}$, and $\overline{d}_{t}$. We then return the distance $d^{*}=\min\{d_{\ell},d_{r},\overline{d}_{\ell},\overline{d}_{r},d_{b},d_{u},\overline{d}_{b},\overline{d}_{u}\}$.

Theorem 4**.**

Given a set $\mathcal{C}$ of $n$ curves, each of size $m$, one can construct a search structure of size $O(nm\log^{7}(nm))$ for segment nearest-curve queries. Given a query segment $s$, one can find in $O(\log^{8}(nm))$ time the curve $C\in\mathcal{C}$ and distance $d^{*}$ such that $d_{dF}(s,C)=d^{*}$ and $d^{*}\leq d_{dF}(s,C^{\prime})$ for all $C^{\prime}\in\mathcal{C}$, under the $L_{\infty}$ metric.

3.2 Input is a set of segments

Let $\mathcal{S}=\{s_{1},\dotsc,s_{n}\}$ be the input set of segments. Given a query curve $Q=(p_{1},\dotsc,p_{m})$, the task is to find a segment $s=ab\in\mathcal{S}$ such that $d_{dF}(Q,s)=\min_{s^{\prime}\in\mathcal{S}}d_{dF}(Q,s^{\prime})$, after suitably preprocessing $\mathcal{S}$. We use an overall approach similar to that used in Section 3.1, however the details of the implementation of the data structure and algorithm differ.

The data structure.

Preprocess the input $\mathcal{S}$ into a four-level search structure $\mathcal{T}$ consisting of a two-dimensional range tree containing the endpoints $a$, and where the associated structure for each node in the second level of the tree is another two-dimensional range tree containing the endpoints $b$ corresponding to the points in the canonical subset of the node.

This structure answers queries consisting of a pair of two-dimensional ranges (i.e., rectangles) $(R,\overline{R})$ and returns all segments $s=ab$ such that $a\in R$ and $b\in\overline{R}$. The preprocessing time for the structure is $O(n\log^{4}{n})$, and the storage is $O(n\log^{3}{n})$. Querying the structure with two rectangles requires $O(\log^{3}{n})$ time, by applying fractional cascading [WL85].

The query algorithm.

Consider the decision version of the problem where, given a query curve $Q$ and a distance $d$, the objective is to determine if there exists a segment $s\in\mathcal{S}$ with $d_{dF}(s,Q)\leq d$. 3 implies that it is sufficient to query the search structure $\mathcal{T}$ with the pair of rectangles $(R_{i}(d),\overline{R}_{i}(d))$ of the curve $Q$, for all $1\leq i\leq m-1$. If $\mathcal{T}$ returns at least one segment for any of the partitions, then this segment is within distance $d$ of $Q$.

As we traverse the curve $Q$ left-to-right, the bounding box of $Q[1,i]$ can be computed at constant incremental cost. For a fixed $d>0$, each rectangle $R_{i}(d)$ can be constructed from the corresponding bounding box in constant time. Rectangle $\overline{R}_{i}(d)$ can be handled similarly by a reverse traversal. Hence all the rectangles can be computed in time $O(m)$, for a fixed $d$. Each pair of rectangles requires a query in $\mathcal{T}$, and thus the time required to answer the decision problem is $O(m\log^{3}{n})$.

Finding the closest segment.

In order to determine the nearest segment $s$ to $Q$, we claim, using an argument similar to that in Section 3.1, for a segment $s=ab$ of distance $d^{*}$ from $Q$ that either $a$ lies on the boundary of $R_{i}(d^{*})$ or $b$ lies on the boundary of $\overline{R}_{i}(d^{*})$ for some $1\leq i<m$. Thus, in order to determine the value of $d^{*}$ it suffices to search over all $8m$ pairs of rectangles where either $a$ or $b$ lies on one of the eight sides of the obtained query rectangles. The sorted list of candidate values of $d$ for each side can be computed in $O(n)$ time from a sorted list of the corresponding $x$- or $y$-coordinates of $a$ or $b$. The smallest value of $d$ for each side is then obtained by a binary search of the sorted list of candidate values. For each of the $O(\log{n})$ evaluated values $d$, a call to $\mathcal{T}$ decides on the existence of a segment within $d$ of $Q$.

Theorem 5**.**

Given an input $\mathcal{S}$ of $n$ segments, a search structure can be preprocessed in $O(n\log^{4}{n})$ time and requiring $O(n\log^{3}{n})$ storage that can answer the following. For a query curve $Q$ of $m$ vertices, find the segment $s^{*}\in\mathcal{S}$ and distance $d^{*}$ such that $d_{dF}(Q,s^{*})=d^{*}$ and $d_{dF}(Q,s)\geq d^{*}$ for all $s\in\mathcal{S}$ under the $L_{\infty}$ metric. The time to answer the query is $O(m\log^{4}{n})$.

4 NNC under translation and $L_{\infty}$ metric

An analogous approach yields algorithms with similar running times for the problems under translation.

For a curve $C$ and a translation $t$, let $C_{t}$ be the curve obtained by translating $C$ by $t$, i.e., by translating each of the vertices of $C$ by $t$. In this section we study the two problems studied in Section 3, assuming the input curves are given up to translation. That is, the distance between the query curve $Q$ and an input curve $C$ is now $\min_{t}d_{dF}(Q,C_{t})$, where the discrete Fréchet distance is computed using the $L_{\infty}$ metric.

4.1 Query is a segment

Let $\mathcal{C}=\{C_{1},\dotsc,C_{n}\}$ be the set of input curves, each of size $m$. We need to preprocess $\mathcal{C}$ for segment nearest-neighbor queries under translation, that is, given a query segment $s=ab$, find the curve $C\in C$ that minimizes $\min_{t}d_{dF}(s,C^{\prime}_{t})=\min_{t}d_{dF}(s_{t},C^{\prime})$, where $s_{t}$ and $C_{t}$ are the images of $s$ and $C$, respectively, under the translation $t$. Let $t^{*}$ be the translation that minimizes $d_{dF}(s_{t},C)$, and set $d^{*}=d_{dF}(s_{t^{*}},C)$. Consider the partition of $C=(p_{1},\ldots,p_{m})$ into prefix $C[1,i]$ and suffix $C[i+1,m]$, such that $a_{t^{*}}\in R_{i}(d^{*})$ and $b_{t^{*}}\in\overline{R}_{i}(d^{*})$. The following trivial observation allows us to construct a set of values to which $d^{*}$ must belong.

Observation 6**.**

One of the following statements holds:

$a_{t^{*}}$* lies on the left side of $R_{i}(d^{*})$ and $b_{t^{*}}$ lies on the right side of $\overline{R}_{i}(d^{*})$, or vice versa, i.e., $a_{t^{*}}$ lies on the right side of $R_{i}(d^{*})$ and $b_{t^{*}}$ lies on the left side of $\overline{R}_{i}(d^{*})$.* 2. 2.

$a_{t^{*}}$* lies on the bottom side of $R_{i}(d^{*})$ and $b_{t^{*}}$ lies on the top side of $\overline{R}_{i}(d^{*})$, or vice versa.*

Assume without loss of generality that $a.x<b.x$ and $a.y<b.y$ and that the first statement holds. Let $\delta_{x}=b.x-a.x$ denote the $x$-span of $s$, and let $\delta_{y}$ denote the $y$-span of $s$. Then, either (i) $(\overline{p}^{i}_{r}.x+d^{*})-(p^{i}_{l}.x-d^{*})=\delta_{x}$, or (ii) $(\overline{p}^{i}_{l}.x-d^{*})-(p^{i}_{r}.x+d^{*})=\delta_{x}$, where as before $p^{i}_{l}$ ($p^{i}_{r}$) is the vertex of $C$ which determines the left (right) side of $R_{i}$ and $\overline{p}^{i}_{l}$ ($\overline{p}^{i}_{r}$) is the vertex of $C$ which determines the left (right) side of $\overline{R}_{i}$. That is, either (i) $d^{*}=\frac{\delta_{x}-(\overline{p}^{i}_{r}.x-p^{i}_{l}.x)}{2}$, or (ii) $d^{*}=\frac{(\overline{p}^{i}_{l}.x-p^{i}_{r}.x)-\delta_{x}}{2}$.

The data structure.

Consider the decision version of the problem: Given $d$, is there a curve in $\mathcal{C}$ whose distance from $s$ under translation is at most $d$? We now present a five-level data structure to answer such decision queries. We continue to assume that $a.x<b.x$ and $a.y<b.y$. For a curve $C_{j}$, let $d^{j}_{i}$ ($\overline{d}^{j}_{i}$) be the smallest radius such that $R^{j}_{i}$ ($\overline{R}^{j}_{i}$) is non-empty, and set $r^{j}_{i}=\max\{d^{j}_{i},\overline{d}^{j}_{i}\}$. The top level of the structure is simply a binary search tree on the $n(m-1)$ values $r^{j}_{i}$; it serves to locate the pairs $(R^{j}_{i}(d),\overline{R}^{j}_{i}(d))$ in which both rectangles are non-empty. The role of the remaining four levels is to filter the set of relevant pairs, so that at the bottom level we remain with those pairs for which $s$ can be translated so that $a$ is in the first rectangle and $b$ is in the second.

For each node $v$ in the top level tree, we construct a search tree over the values $\overline{p}^{i}_{r}.x-p^{i}_{l}.x$ corresponding to the pairs in the canonical subset of $v$. These trees constitute the second level of the structure. The third-level trees are search trees over the values $\overline{p}^{i}_{l}.x-p^{i}_{r}.x$, the fourth-level ones — over the values $\overline{p}^{i}_{t}.y-p^{i}_{b}.y$, and finally the fifth-level ones — over the values $\overline{p}^{i}_{b}.y-p^{i}_{t}.y$.

The query algorithm.

Given a query segment $s=ab$ (with $a.x<b.x$ and $a.y<b.y$) and $d>0$, we employ our data structure to answer the decision problem. In the top level, we select all pairs $(R^{j}_{i},\overline{R}^{j}_{i})$ satisfying $r^{j}_{i}\leq d$. Of these pairs, in the second level, we select all pairs satisfying $\overline{p}^{i}_{r}.x-p^{i}_{l}.x\geq\delta_{x}-2d$. In the third level, we select all pairs satisfying $\overline{p}^{i}_{l}.x-p^{i}_{r}.x\leq\delta_{x}+2d$. Similarly, in the fourth level, we select all pairs satisfying $\overline{p}^{i}_{t}.y-p^{i}_{b}.y\geq\delta_{y}-2d$, and in the fifth level, we select all pairs satisfying $\overline{p}^{i}_{b}.y-p^{i}_{t}.y\leq\delta_{y}+2d$. At this point, if our current set of pairs is non-empty, we return yes, otherwise, we return no.

To find the nearest curve $C$ and the corresponding distance $d^{*}$, we proceed as follows, utilizing the observation above. We perform a binary search over the $O(nm)$ values of the form $\overline{p}^{i}_{r}.x-p^{i}_{l}.x$ to find the largest value for which the decision algorithm returns yes on $d=\frac{\delta_{x}-(\overline{p}^{i}_{r}.x-p^{i}_{l}.x)}{2}$. (We only consider the values $\overline{p}^{i}_{r}.x-p^{i}_{l}.x$ that are smaller than $\delta_{x}$.) Similarly, we perform a binary search over the values $\overline{p}^{i}_{t}.y-p^{i}_{b}.y$ to find the largest value for which the decision algorithm returns yes on $d=\frac{\delta_{y}-(\overline{p}^{i}_{t}.y-p^{i}_{b}.y)}{2}$. We perform two more binary searches; one over the values $\overline{p}^{i}_{l}.x-p^{i}_{r}.x$ to find the smallest value for which the decision algorithms returns yes on $d=\frac{(\overline{p}^{i}_{l}.x-p^{i}_{r}.x)-\delta_{x}}{2}$, and one over the values $\overline{p}^{i}_{b}.y-p^{i}_{t}.y$. Finally, we return the smallest $d$ for which the decision algorithm has returned yes.

Our data structure was designed for the case where $b$ lies to the right and above $a$. Symmetric data structures for the other three cases are also needed. The following theorem summarizes the main result of this section.

Theorem 7**.**

Given a set $\mathcal{C}$ of $n$ curves, each of size $m$, one can construct a search structure of size $O(nm\log^{4}(nm))$, such that, given a query segment $s$, one can find in $O(\log^{6}(nm))$ time the curve $C\in C$ nearest to $s$ under translation, that is the curve minimizing $\min_{t}d_{dF}(s_{t},C^{\prime})$, where the discrete Fréchet distance is computed using the $L_{\infty}$ metric.

4.2 Input is a set of segments

Let $\mathcal{S}=\{s_{1},\dotsc,s_{n}\}$ be the input set of segments, with $s_{i}=a_{i}b_{i}$. We need to preprocess $\mathcal{S}$ for nearest-neighbor queries under translation, that is, given a query curve $Q=(p_{1},\dots,p_{m})$, find the segment $s=ab\in\mathcal{S}$ that minimizes $\min_{t}d_{dF}(Q,s^{\prime}_{t})=\min_{t}d_{dF}(Q_{t},s^{\prime})$. Since translations are allowed, without loss of generality we can assume that the first point of all the segments is the origin. In other words, the input is converted to a two-dimensional point set $\mathcal{C}=\{c_{i}=b_{i}-a_{i}\mid a_{i}b_{i}\in\mathcal{S}\}$.

The idea is to find the nearest segment corresponding to each of the $m-1$ partitions of the query. Let $s=ab$ be any segment and $d$ some radius. The following observation holds for any partition of $Q$ into $Q[1,i]$ and $Q[i+1,m]$, where $R_{i}^{\oplus}(d)=(-R_{i}(d))\oplus\overline{R}_{i}(d)$ and $\oplus$ is the Minkowski sum operator, see Figure 2.

Observation 8**.**

There exists a translation $t$ such that $a_{t}\in R_{i}(d)$ and $b_{t}\in\overline{R}_{i}(d)$ if and only if $c=b-a\in R_{i}^{\oplus}(d)$.

Based on this observation segment $ab$ is within distance $d$ of $Q$ under translation, if for some $i$, $R_{i}^{\oplus}(d)$ contains the point $c=b-a$, which means translations can be handled implicitly.

The data structure.

According to 8, a data structure is required to answer the following question: Given a partition of $Q$ into prefix $Q[1,i]$ and suffix $Q[i+1,m]$, what is the smallest radius $d^{*}$ so that $R_{i}^{\oplus}(d^{*})$ contains some $c_{j}\in\mathcal{C}$? The smallest radius $d^{\prime}$ where both $R_{i}(d^{\prime})$ and $\overline{R}_{i}(d^{\prime})$—and hence $R_{i}^{\oplus}(d^{\prime})$—are nonempty can be determined in linear time. This value which depends on $i$ is a lower bound on $d^{*}$.

Since $-R_{i}(d^{\prime})$ and $\overline{R}_{i}(d^{\prime})$ are both axis-aligned rectangles (segments or points in special cases), their Minkowski sum, $R_{i}^{\oplus}(d^{\prime})$, is also a possibly degenerate axis-aligned rectangle. If this rectangle contains some point $c_{j}\in\mathcal{C}$, then $s_{j}$ is the nearest segment with respect to this partition and the optimal distance is $d^{\prime}$. If it contains more than one point from $\mathcal{C}$, then all the corresponding segments are equidistant from the query and each of them can be reported as the nearest neighbor corresponding to this partition. The data structure needed here is a two-dimensional range tree on $\mathcal{C}$.

If $R_{i}^{\oplus}(d^{\prime})\cap\mathcal{C}$ is empty, then we need to find the smallest radius $d^{*}$ so that $R_{i}^{\oplus}(d^{*})$ contains some $c_{j}$. For any distance $d>d^{\prime}$, $R_{i}^{\oplus}(d)$ is a rectangle concentric with $R_{i}^{\oplus}(d^{\prime})$ but whose edges are longer by an additive amount of $4(d-d^{\prime})$.

As $d$ increases, the four edges of the rectangle sweep through 4 non-overlapping regions in the plane, so any point in the plane that gets covered by $R_{i}^{\oplus}(d)$, first appears on some edge. We divide this problem into 4 sub-problems based on the edge that the optimal $c_{j}$ might appear on. Below, we solve the sub-problem for the right edge of the rectangle: Given a partition of $Q$ into prefix $Q[1,i]$ and suffix $Q[i+1,m]$, what is the smallest radius $d_{r}^{*}$ so that the right edge of $R_{i}^{\oplus}(d_{r}^{*})$ contains some $c_{j}$? All other sub-problems are solved symmetrically.

Any point $c_{j}$ that appears on the right edge belongs to the intersection of three half-planes:

On or below the line of slope $+1$ passing through the top-right corner of the rectangle $R_{i}^{\oplus}(d^{\prime})$. 2. 2.

On or above the line of slope $-1$ passing through the bottom-right corner of $R_{i}^{\oplus}(d^{\prime})$. 3. 3.

To the right of the line through the right edge of $R_{i}^{\oplus}(d^{\prime})$.

The first point in this region swept by the right edge of the growing rectangle $R_{i}^{\oplus}(d)$ is the one with the smallest $x$-coordinate. This point can be located using a three-dimensional range tree on $\mathcal{C}$.

The query algorithm.

Given a query curve $Q=(p_{1},\dotsc,p_{m})$, the nearest segment under translation can be determined by using the data structure to find the nearest segment—and its distance from $Q$—for each of the $m-1$ partitions and selecting the segment whose distance is smallest.

As stated in Section 3.2, all $O(m)$ bounding boxes can be computed in $O(m)$ total time. For a particular partition, knowing the two bounding boxes, one can determine the smallest radius $d^{\prime}$ where $R_{i}^{\oplus}(d^{\prime})$ is nonempty in constant time. Now the two-dimensional range tree on $\mathcal{C}$ is used to search for points inside $R_{i}^{\oplus}(d^{\prime})$. If the data structure returns some point $c\in\mathcal{C}$, then the segment corresponding to $c$ is the nearest segment under translation. Otherwise, one has to do four three-level range searches in the second data structure and compare the results to find the nearest segment. This is the most expensive step which takes $O(\log^{2}{n})$ time using fractional cascading [WL85]. The following theorem summarizes the main result of this section.

Theorem 9**.**

Given a set $\mathcal{S}$ of $n$ segments, one can construct a search structure of size $O(n\log^{2}{n})$, so that, given a query curve $Q$ of size $m$, one can find in $O(m\log^{2}{n})$ time the segment $s\in\mathcal{S}$ nearest to $Q$ under translation, that is the segment minimizing $\min_{t}d_{dF}(Q,s^{\prime}_{t})$, where the discrete Fréchet distance is computed using the $L_{\infty}$ metric.

5 NNC and $L_{2}$ metric

In this section, we present algorithms for approximate nearest-neighbor search under the discrete Fréchet distance using $L_{2}$. Notice that the algorithms from Section 3 for the $L_{\infty}$ version of the problem, already give $\sqrt{2}$-approximation algorithms for the $L_{2}$ version. Next, we provide $(1+\varepsilon)$-approximation algorithms.

5.1 Query is a segment

Let $\mathcal{C}=\{C_{1},\ldots,C_{n}\}$ be a set of $n$ polygonal curves in the plane. The $(1+\varepsilon)$-approximate nearest-neighbor problem is defined as follows: Given $0<\varepsilon\leq 1$, preprocess $\mathcal{C}$ into a data structure supporting queries of the following type: given a query segment $s$, return a curve $C^{\prime}\in\mathcal{C}$, such that $d_{dF}(s,C^{\prime})\leq(1+\varepsilon)d_{dF}(s,C)$, where $C$ is the curve in $\mathcal{C}$ closest to $s$.

Here we provide a data structure for the $(1+\varepsilon,r)$-approximate nearest-neighbor problem, defined as: Given a parameter $r$ and $0<\varepsilon\leq 1$, preprocess $\mathcal{C}$ into a data structure supporting queries of the following type: given a query segment $s$, if there exists a curve $C_{i}\in\mathcal{C}$ such that $d_{dF}(s,C_{i})\leq r$, then return a curve $C_{j}\in\mathcal{C}$ such that $d_{dF}(s,C_{j})\leq(1+\varepsilon)r$.

There exists a reduction from the $(1+\varepsilon)$-approximate nearest-neighbor problem to the $(1+\varepsilon,r)$-approximate nearest-neighbor problem [Ind00], at the cost of an additional logarithmic factor in the query time.

An exponential grid.

Given a point $p\in\mathbb{R}^{2}$, a parameter $0<\varepsilon\leq 1$, and an interval $[\alpha,\beta]\subseteq\mathbb{R}$, we can construct the following exponential grid $G(p)$ around $p$, which is a slightly different version of the exponential grid presented in [Dri13]:

Consider the series of axis-parallel squares $S_{i}$ centered at $p$ and of side lengths $\lambda_{i}=2^{i}\alpha$, for $i=1,\dotsc,\lceil\log(\beta/\alpha)\rceil$. Inside each region $S_{i}\setminus S_{i-1}$ (for $i>1$), construct a grid $G_{i}$ of side length $\frac{\varepsilon\lambda_{i}}{2\sqrt{2}}$. The total number of grid cells is at most

[TABLE]

Given a point $q\in\mathbb{R}^{2}$ such that $\alpha\leq\|q-p\|\leq\beta$, let $i$ be the smallest index such that $q\in S_{i}$. If $q$ is in $S_{1}$, then $\|q-p\|\leq\sqrt{2}\alpha$. Else, we have $i>1$. Let $g$ be the grid cell of $G_{i}$ that contains $q$, and denote by $c_{g}$ the center point of $g$. So we have $\|q-c_{g}\|\leq\frac{\sqrt{2}}{2}\frac{\varepsilon\lambda_{i}}{2\sqrt{2}}=\frac{\varepsilon}{2}2^{i-1}\alpha\leq\frac{\varepsilon}{2}2^{\log(\beta/\alpha)}\alpha=\frac{\varepsilon\beta}{2}$.

A data structure for $(1+\varepsilon,r)$-ANNC.

For each curve $C_{i}=(p^{i}_{1},\ldots,p^{i}_{m})\in\mathcal{C}$, we construct two exponential grids: $G(p^{i}_{1})$ around $p^{i}_{1}$ and $G(p^{i}_{m})$ around $p^{i}_{m}$, both with the range $[\frac{\varepsilon r}{2\sqrt{2}},\,r]$, as described above. Now, for each pair of grid cells $(g,h)\in G(p^{i}_{1})\times G(p^{i}_{m})$, let $C(g,h)=C\in\mathcal{C}$ be the curve such that $d_{dF}(c_{g}c_{h},C)=\min_{j}\{d_{dF}(c_{g}c_{h},C_{j})\}$. In other words, $C(g,h)$ is the closest input curve to the segment $c_{g}c_{h}$.

Let $\mathcal{G}_{1}$ be the union of the grids $G(p^{1}_{1}),G(p^{2}_{1}),\dotsc,G(p^{n}_{1})$, and $\mathcal{G}_{m}$ the union of the grids $G(p^{1}_{m}),G(p^{2}_{m}),\dotsc,G(p^{n}_{m})$. The number of grid cells in each grid is $O((1/\varepsilon)^{2}\lceil\log(r/\frac{\varepsilon r}{2\sqrt{2}})\rceil)=O(\frac{1}{\varepsilon^{2}}\log(1/\varepsilon))$. The number of grid cells in $\mathcal{G}_{1}$ and $\mathcal{G}_{m}$ is thus $O(n\frac{1}{\varepsilon^{2}}\log(1/\varepsilon))$.

The data structure is a four-level segment tree, where each grid cell is represented in the structure by its bottom- and left-edges. The first level is a segment tree for the horizontal edges of the cells of $\mathcal{G}_{1}$. The second level corresponds to the vertical edges of the cells of $\mathcal{G}_{1}$: for each node $u$ in the first level, a segment tree is constructed for the set of vertical edges that correspond to the horizontal edges in the canonical subset of $u$. That is, if some horizontal edge of a cell in $G(p^{i}_{1})$ is in $u$’s canonical subset, then the vertical edge of the same cell is in the segment tree of the second level associated with $u$. Levels three and four of the data structure correspond to the horizontal and vertical edges, respectively, of the cells in $\mathcal{G}_{m}$.

The third level is constructed as follows. For each node $u$ in the second level, we construct a segment tree for the subset of horizontal edges of cells in $\mathcal{G}_{m}$ which corresponds to the canonical set of $u$; that is, if a vertical edge of $G(p^{i}_{1})$ is in $u$’s canonical subset, then all the horizontal edges of $G(p^{i}_{m})$ are in the subset corresponding to $u$’s canonical set. Thus, the size of the third-level subset is $O(\frac{1}{\varepsilon^{2}}\log(1/\varepsilon))$ times the size of the second-level subset.

Each node of the forth level corresponds to a subset of pairs of grid cells from the set $\bigcup\limits_{i=1}^{n}(G(p^{i}_{1})\times G(p^{i}_{m}))$. In each such node $u$ we store the curve $C(g,h)$ such that $(g,h)$ is the pair in $u$’s corresponding set for which $d_{dF}(c_{g}c_{h},C(g,h))$ is minimum.

Given a query segment $s=ab$, we can obtain all pairs of grid cells $(g,h)\in\bigcup\limits_{i=1}^{n}(G(p^{i}_{1})\times G(p^{i}_{m}))$, such that $a\in g$ and $b\in h$, as a collection of $O(\log^{4}(\frac{n}{\varepsilon}))$ canonical sets in $O(\log^{4}(\frac{n}{\varepsilon}))$ time. Then, we can find, within the same time bound, the pair of cells $g,h$ among them for which $d_{dF}(c_{g}c_{h},C(g,h))$ is minimum. The space required is $O(n\frac{1}{\varepsilon^{4}}\log^{4}(\frac{n}{\varepsilon}))$.

The query algorithm.

Given a query segment $s=ab$, let $p,q$ be the pair of cell center points returned when querying the data structure with $s$, and let $C_{j}\in\mathcal{C}$ be the closest curve to $pq$. We show that if there exists a curve $C_{i}\in\mathcal{C}$ with $d_{dF}(ab,C_{i})\leq r$, then $d_{dF}(ab,C_{j})\leq(1+\varepsilon)r$.

Since $d_{dF}(ab,C_{i})\leq r$, it holds that $d_{dF}(ab,p^{i}_{1}p^{i}_{m})\leq r$, and thus there exists a pair of grid cells $g\in G(p^{i}_{1})$ and $h\in G(p^{i}_{m})$ such that $a\in g$ and $b\in h$. The data structure returns $p,q$, so we have $d_{dF}(pq,C_{j})\leq d_{dF}(c_{g}c_{h},C_{i})$  (1). The properties of the exponential grids $G(p^{i}_{1})$ and $G(p^{i}_{m})$ guarantee that $\|a-c_{g}\|,\|b-c_{h}\|\leq\max\{\sqrt{2}\alpha,\frac{\varepsilon\beta}{2}\}=\frac{\varepsilon}{2}r$. Therefore, $d_{dF}(c_{g}c_{h},ab)\leq\frac{\varepsilon}{2}r$  (2), and, similarly, $d_{dF}(pq,ab)\leq\frac{\varepsilon}{2}r$  (3). By the triangle inequality and Equation (2), $d_{dF}(c_{g}c_{h},C_{i})\leq d_{dF}(c_{g}c_{h},ab)+d_{dF}(ab,C_{i})\leq(1+\frac{\varepsilon}{2})r$  (4). Finally, by the triangle inequality and Equations (1), (3) and (4),

[TABLE]

Theorem 10**.**

Given a set $\mathcal{C}$ of $n$ curves, each of size $m$, and $0<\varepsilon\leq 1$, one can construct a search structure of size $O(\frac{n}{\varepsilon^{4}}\log^{4}(\frac{n}{\varepsilon}))$ for approximate segment nearest-neighbor queries. Given a query segment $s$, one can find in $O(\log^{5}(\frac{n}{\varepsilon}))$ time a curve $C^{\prime}\in\mathcal{C}$ such that $d_{dF}(s,C^{\prime})\leq(1+\varepsilon)d_{dF}(s,C)$, under the $L_{2}$ metric, where $C$ is the curve in $\mathcal{C}$ closest to $s$.

5.2 Input is a set of segments

In Section 3.2, we presented an exact algorithm for the problem under $L_{\infty}$, in which we compute the intersections of the squares of radius $d$ around the vertices of the query curve, and use a two-level data structure for rectangle-pair queries.

To achieve an approximation factor of $(1+\varepsilon)$ for the problem under $L_{2}$, we can use the same approach, except that instead of squares we use regular $k$-gons. Given a query curve $Q=(p_{1},\dotsc,p_{m})$, the intersections of the regular $k$-gons of radius $d$ around the vertices of $Q$ are polygons with at most $k$ edges, defined by at most $k$ sides of the regular $k$-gons. The orientations of the edges of the intersections are fixed, and thus we can construct a two-level data structure for $k$-gon-pair queries, where each level consists of $k$ inner levels, one for each possible orientation. The size of such a data structure is thus $O(n\log^{2k}n)$.

Given a parameter $\varepsilon$, we pick $k=O(\frac{1}{\sqrt{\varepsilon}})$, so that the approximation factor is $(1+\varepsilon)$, the space complexity is $O(n\log^{O(\frac{1}{\sqrt{\varepsilon}})}n)$ and the query time is $O(m\log^{O(\frac{1}{\sqrt{\varepsilon}})}n)$.

Theorem 11**.**

Given an input $\mathcal{S}$ of $n$ segments, and $0<\varepsilon\leq 1$, one can construct a search structure of size $O(n\log^{O(\frac{1}{\sqrt{\varepsilon}})}n)$ for approximate segment nearest-neighbor queries. Given a query curve $Q$ of size $m$, one can find in $O(m\log^{O(\frac{1}{\sqrt{\varepsilon}})}n)$ time a segment $s^{\prime}\in\mathcal{S}$ such that $d_{dF}(s^{\prime},Q)\leq(1+\varepsilon)d_{dF}(s,Q)$, under the $L_{2}$ metric, where $s$ is the segment in $\mathcal{S}$ closest to $Q$.

6 $(1,2)$-Center

The objective of the $(1,2)$-Center problem is to find a segment $s$ such that $\max_{C_{i}\in\mathcal{C}}d_{dF}(s,C_{i})$ is minimized. This can be reformulated equivalenly as: Find a pair of balls $(B,\overline{B})$, such that (i) for each curve $C\in\mathcal{C}$, there exists a partition at $1\leq i<m$ of $C$ into prefix $C[1,i]$ and suffix $C[i+1,m]$, with $C[1,i]\subseteq B$ and $C[i+1,m]\subseteq\overline{B}$, and (ii) the radius of the larger ball is minimized.

6.1 $(1,2)$-Center and $L_{\infty}$ metric

An optimal solution to the $(1,2)$-Center problem under the $L_{\infty}$ metric is a pair of squares $(S,\overline{S})$, where $S$ contains all the prefix vertices and $\overline{S}$ contains all the suffix vertices. Assume that the optimal radius is $r^{*}$, and that it is determined by $S$, i.e., the radius of $S$ is $r^{*}$ and the radius of $\overline{S}$ is at most $r^{*}$. Then, there must exist two determining vertices $p,p^{\prime}$, belonging to the prefixes of their respective curves, such that $p$ and $p^{\prime}$ lie on opposite sides of the boundary of $S$. Clearly, $||p-p^{\prime}||_{\infty}=2r^{*}$. Let the positive normal direction of the sides be the determining direction of the solution.

Let $R$ be the axis-aligned bounding rectangle of $C_{1}\cup\dots\cup C_{n}$, and denote by $e_{\ell}$, $e_{r}$, $e_{t}$, and $e_{b}$ the left, right, top, and bottom edges of $R$, respectively.

Lemma 12**.**

At least one of $p,p^{\prime}$ must lie on the boundary of $R$.

Proof.

Assume that the determining direction is the positive $x$-direction, and that neither $p$ nor $p^{\prime}$ lies on the boundary of $R$. Thus, there must exist a pair of vertices $q,q^{\prime}\in\overline{S}$ with $q.x<p.x$ and $q^{\prime}.x>p^{\prime}.x$, which implies that $||q-q^{\prime}||_{\infty}>||p-p^{\prime}||_{\infty}=2r^{*}$, contradicting the assumption that $p,p^{\prime}$ are the determining vertices. ∎

We say that a corner of $S$ (or $\overline{S}$) coincides with a corner of $R$ when the corner points are incident, and they are both of the same type, i.e., top-left, bottom-right, etc.

Lemma 13**.**

There exists an optimal solution $(S,\overline{S})$ where at least one corner of $S$ or $\overline{S}$ coincides with a corner of $R$.

Proof.

Let $p,p^{\prime}\in S$ be a pair of determining vertices, and assume, without loss of generality, that $p$ lies on the boundary of $R$. If $p$ is a corner of $R$, then the claim trivially holds. Otherwise, $p$ lies in the interior of an edge of $R$, and assume without loss of generality that it lies on $e_{\ell}$. If $S$ contains a vertex on $e_{t}$, then we can shift $S$ vertically down until its top edge overlaps $e_{t}$. Else, if it contains a vertex on $e_{b}$, then we can shift $S$ up until its bottom edge overlaps $e_{b}$. In both cases, the lemma conclusion holds.

If $S$ does not contain any vertex from $e_{t}$ or $e_{b}$, then clearly $\overline{S}$ must contain vertices $q\in e_{t}$ and $q^{\prime}\in e_{b}$ with $||q-q^{\prime}||_{\infty}\leq 2r^{*}$. Therefore, $S$ intersects $e_{b}$ or $e_{t}$ (or both), and can be shifted vertically until its boundary overlaps $e_{b}$ or $e_{t}$, as desired.

A symmetric argument can be made when $p$ and $p^{\prime}$ are suffix vertices, i.e., $p,p^{\prime}\in\overline{S}$. ∎

Lemma 13 implies that for a given input $\mathcal{C}$ where the determining vertices are in $S$, there must exist an optimal solution where $S$ is positioned so that one of its corners coincides with a corner of the bounding rectangle, and that one of the determining vertices is on the boundary of $R$. The optimal solution can thus be found by testing all possible candidate squares that satisfy these properties and returning the valid solution that yields the smallest radius. The algorithm presented in the sequel will compute the radius $r^{*}$ of an optimal solution $(S^{*},\overline{S^{*}})$ such that $r^{*}$ is determined by the prefix square $S^{*}$, see Figure 3. The solution where $r^{*}$ is determined by $\overline{S^{*}}$ can be computed in a symmetric manner.

For each corner $v$ of the bounding rectangle $R$, we sort the $(m-2)n$ vertices in $C_{1}\cup\dots\cup C_{n}$ that are not endpoints—the initial vertex of each curve must always be contained in the prefix, and the final vertex in the suffix—by their $L_{\infty}$ distance from $v$. Each vertex $p$ in this ordering is associated with a square $S$ of radius $||v-p||_{\infty}/2$, coinciding with $R$ at corner $v$.

A sequential pass is made over the vertices, and their respective squares $S$, and for each $S$ we compute the radius of $S$ and $\overline{S}$ using the following data structures. We maintain a balanced binary tree $T_{C}$ for each curve $C\in\mathcal{C}$, where the leaves of $T_{C}$ correspond to the vertices of $C$, in order. Each node of the tree contains a single bit: The bit at a leaf node corresponding to vertex $p_{j}$ indicates whether $p_{j}\in S$, where $S$ is the current square. The value of the bit at a leaf of $T_{C}$ can be updated in $O(\log{m})$ time. The bit of an internal node is 1 if and only if all the bits in the leaves of its subtree are 1, and thus the longest prefix of $C$ can be determined in $O(\log{m})$ time. At each step in the pass, the radius of $\overline{S}$ must also be computed, and this is obtained by determining the bounding box of the suffix vertices. Thus, two balanced binary trees are maintained: $\overline{T}_{x}$ contains a leaf for each of the suffix vertices ordered by their $x$-coordinate; and $\overline{T}_{y}$ where the leaves are ordered by the $y$-coordinate. The extremal vertices that determine the bounding box can be determined in $O(\log{mn})$ time. Finally, the current optimal squares $S^{*}$ and $\overline{S^{*}}$, and the radius $r^{*}$ of $S^{*}$ are persisted.

The trees $T_{C_{1}},\ldots,T_{C_{n}}$ are constructed with all bits initialized to 0, except for the bit corresponding to the initial vertex in each tree which is set to 1, taking $O(nm)$ time in total. $\overline{T}_{x}$ and $\overline{T}_{y}$ are initialized to contain all non-initial vertices in $O(mn\log{mn})$ time. The optimal square $S^{*}$ containing all the initial vertices is computed, and $\overline{S^{*}}$ is set to contain the remaining vertices. The optimal radius $r^{*}$ is the larger of the radii induced by $S^{*}$ and $\overline{S^{*}}$.

At the step in the pass for vertex $p$ of curve $C_{j}$ whose associated square is $S$, the leaf of $T_{C}$ corresponding to $p$ is updated from [math] to $1$ in $O(\log{m})$ time. The index $i$ of the longest prefix covered by $S$ can then be determined, also in $O(\log{m})$ time. The vertices from $C_{j}$ that are now in the prefix must be deleted from $\overline{T}_{x}$ and $\overline{T}_{y}$, and although there may be $O(m)$ of them in any iteration, each will be deleted exactly once, and so the total update time over the entire sequential pass is $O(mn\log{mn})$. The radius of the square $S$ is $\|v-p\|_{\infty}/2$, and the radius of $\overline{S}$ can be computed in $O(\log{mn})$ time as half the larger of $x$- and $y$-extent of the suffix bounding box. The optimal squares $S^{*}$, $\overline{S^{*}}$, and the cost $r^{*}$ are updated if the radius of $S$ determines the cost, and the radius of $S$ is less than the existing value of $r^{*}$.

Finally, we return the optimal pair of squares $(S^{*},\overline{S^{*}})$ with the minimal cost $r^{*}$.

Theorem 14**.**

Given a set of curves $\mathcal{C}$ as input, an optimal solution to the $(1,2)$-Center problem using the discrete Fréchet distance under the $L_{\infty}$ metric can be computed in time $O(mn\log{mn})$ using $O(mn)$ storage.

6.2 $(1,2)$-Center under translation and $L_{\infty}$ metric

The $(1,2)$-Center problem under translation and the $L_{\infty}$ metric can be solved using a similar approach. The objective is to find a segment $s^{*}$ that minimizes the maximum discrete Fréchet distance under $L_{\infty}$ between $s^{*}$ and the input curves whose locations are fixed only up to translation. A solution will be a pair of squares $(S,\overline{S})$ of equal size and whose radius $r^{*}$ is minimal, such that, for each $C\in\mathcal{C}$, there exists a translation $t$ and a partition index $i$ where $C_{t}[1,i]\subset S$ and $C_{t}[i+i,m]\subset\overline{S}$. Clearly, an optimal solution will not be unique as the curves can be uniformly translated to obtain an equivalent solution, and moreover, in general there is freedom to translate either square in the direction of at least one of the $x$- or $y$-axes.

Let $\operatorname{\mathit{\delta_{x}}}(C)$ be the $x$-extent of the curve $C$ and $\operatorname{\mathit{\delta_{y}}}(C)$ be the $y$-extent. Let $R$ be the closed rectangle whose bottom-left corner lies at the origin and whose top-right corner is located at $(\delta_{x}^{*},\delta_{y}^{*})$ where $\delta_{x}^{*}:=\max_{C\in\mathcal{C}}\operatorname{\mathit{\delta_{x}}}(C)$ and $\delta_{y}^{*}:=\max_{C\in\mathcal{C}}\operatorname{\mathit{\delta_{y}}}(C)$. Furthermore, let $w_{\ell}$ and $w_{r}$ be the left- and right-most vertices in a curve with $x$-span $\delta_{x}^{*}$, and let $w_{t}$ and $w_{b}$ be the top- and bottom-most vertices in a curve with $y$-span $\delta_{y}^{*}$. Clearly, all curves in $\mathcal{C}$ can be translated to be contained within $R$, and for all such sets of curves under translation, the extremal vertices $w_{t}$, $w_{b}$, $w_{\ell}$ and $w_{r}$ each must lie on the corresponding side of $R$. We claim that if a solution exists with radius $r^{*}$, then an equivalent solution $(S,\overline{S})$ can be obtained using the same partition of each curve, where $S$ and $\overline{S}$ are placed at opposite corners of $R$.

Lemma 15**.**

Given a set $\mathcal{C}$ of $n$ curves, if there exists a solution of radius $r^{*}$ to the problem, then there also exists a solution $(S,\overline{S})$ of radius $r^{*}$ where a corner of $S$ and a corner of $\overline{S}$ coincide with opposite corners of the rectangle $R$.

Proof.

Let $(S^{\prime},\overline{S^{\prime}})$ be a solution of radius $r^{*}$ where all the curves under translation are not necessarily contained in $R$, and the corners of $S^{\prime}$ and $\overline{S^{\prime}}$ do not coincide with the corners of $R$. The proof is constructive: The coordinate system is defined such that prefix square $S^{\prime}$ is positioned so that its corner coincides with the appropriate corner of $R$ ensuring that $S^{\prime}\equiv S$, and we define a continuous family of squares $\overline{S}(\lambda)$ parameterized on $\lambda\in[0,1]$ where $\overline{S}(0)=\overline{S^{\prime}}$ and $\overline{S}(1)=\overline{S}$, such that $\overline{S}$ coincides with the opposite corner of $R$. This family traces a translation of $\overline{S}(\lambda)$, first in the $x$-direction and then in the $y$-direction, and we show that the prefix and suffix of each curve—possibly under translation—remain within $S$ and $\overline{S}(\lambda)$, and thus the solution remains valid.

We prove this for the case where the top-right corner $v$ of $S^{\prime}$ is below-left the top-right corner $\overline{v}$ of $\overline{S^{\prime}}$, i.e., $v.x\leq\overline{v}.x$ and $v.y\leq\overline{v}.y$. In the sequel we will show that an equivalent solution $(S,\overline{S})$ exists where the bottom-left corner of $S$ lies at the origin and the top-right corner of $\overline{S}$ lies at $(\delta_{x}^{*},\delta_{y}^{*})$ as required by the claim in the lemma. A symmetric argument exists for the other cases where $v$’s position relative to $\overline{c}$ is above-left, below-right and below-left.

First, observe that $\overline{v}.x\geq\delta_{x}^{*}$, as either $w_{r}$ is a vertex in a prefix of some curve and thus $\delta_{x}^{*}\leq v.x\leq\overline{v}.x$, or $w_{r}$ is a vertex in a suffix and thus $\delta_{x}^{*}\leq\overline{v}.x$. A similar argument proves that $\overline{v}.y\geq\delta_{y}^{*}$, and thus $\overline{S}(\lambda)$ will move to the left until the $x$-coordinate of the right edge of $\overline{S}$ is $\delta_{x}^{*}$ and then down under the continuous translation to $\overline{S}$, i.e., the $y$-coordinate of the top edge of $\overline{S}$ is $\delta_{y}^{*}$.

Consider the validity of the solution $(S,\overline{S}(\lambda))$ as the suffix square moves leftwards. If there are no suffix vertices on the right edge of square $\overline{S}(\lambda)$ then it can be translated to the left and remain a valid solution, until such time as some suffix vertex $\overline{p}$ of curve $C$ lies on the right edge. Subsequently, $C$ is translated together with $\overline{S}(\lambda)$, and thus the suffix vertices of $C$ continue to be contained in $\overline{S}(\lambda)$. For a prefix vertex $p$ of $C$ to move outside $S$ under the translation it must cross the left-side of $S$, however this would imply that $|\overline{p}.x-p.x|>\overline{p}.x\geq\delta_{x}^{*}$, contradicting the fact that $\delta_{x}^{*}$ is the maximum extent in the $x$-direction of all curves. The same analysis can be applied to the translation of $\overline{S}(\lambda)$ in the downward direction. This shows that the continuous family of squares $\overline{S}(\lambda)$ imply a family of optimal solutions $(S,\overline{S}(\lambda))$ to the problem, and in particular $(S,\overline{S})$ is a solution. ∎

Lemma 15 implies that an optimal solution of radius $r^{*}$ exists where $S$ and $\overline{S}$ coincide with opposite corners of $R$. Next, we consider the properties of such an optimal solution, and show that $r^{*}$ is determined by two vertices from a single curve. Recall that a pair of vertices are determining vertices if they lie on opposite sides of one of the squares. Here, we refine the definition with the condition that the pair both belong to the prefix or suffix of the same curve. Furthermore, denote a pair of vertices $(p,\overline{p})$, where $p$ is in the prefix and $\overline{p}$ is in the suffix of the same curve, as opposing vertices if they preclude a smaller pair of squares coincident with the same opposing corners of $R$. Assuming that $S$ coincides with the top-left corner of $R$ and $\overline{S}$ with the bottom-right corner, then $p$ and $\overline{p}$ are opposing vertices if, either: (i) $p$ lies on the right edge of $S$ and $\overline{p}$ lies on the left edge of $\overline{S}$; or (ii) $p$ lies on bottom edge of $S$ and $\overline{p}$ lies on the top edge of $\overline{S}$. Symmetrical conditions exist for the cases where $S$ and $\overline{S}$ are coincident with the other three (ordered) pairs of corners. We claim that the conditions in the following lemma are necessary for a solution.

Lemma 16**.**

Let $(S,\overline{S})$ be an optimal solution of radius $r^{*}$ such that $S$ and $\overline{S}$ are coincident with opposite corners of $R$, and let $\mathcal{C}^{\prime}:=\{C_{t}\mid C\in\mathcal{C}\}$ be the set of curves under translation from which $(S,\overline{S})$ was obtained. At least one of the following conditions must hold for some curve $C_{t}\in\mathcal{C}^{\prime}$:

1. (i)

there must be a pair of determining vertices for either $S$ or $\overline{S}$; or 2. (ii)

there must be a pair of opposing vertices for $S$ and $\overline{S}$.

Proof.

Since $(S,\overline{S})$ is a valid solution, then for each translated curve $C_{t}\in\mathcal{C}^{\prime}$, there must exist a partition of $C_{t}$ defined by an index $i$ such that $C_{t}[1,i]\subset S$ and $C_{t}[i+1,m]\subset\overline{S}$. Assume that neither of the conditions stated in the lemma hold. Then the radius of the squares can be decreased to obtain a smaller pair of squares coincident with the same corners of $R$. If no vertices from the curves in $\mathcal{C}^{\prime}$ lie on the inner sides of $S$ and $\overline{S}$—that is, the sides that are not collinear with sides of $R$—then the radius can be reduced without translating the curves in $\mathcal{C}^{\prime}$. If one or more prefix (suffix) vertices of lie on the inner sides of $S$ ($\overline{S}$), then $C_{t}$ is translated in a direction determined in the following way. For each such vertex $p$ lying on a side $s$ of its assigned square, let $\vec{n}$ be the direction of the inner normal of $s$. The direction of translation is the direction of the vector obtained by summing the normal vectors. Such a direction would allow all the vertices lying on the sides of their respective squares to remain on the side, unless two vertices lie on opposing sides of the same square, i.e., condition (i) holds, or they lie on the opposing inner sides of different squares, i.e., condition (ii) holds. ∎

Lemma 16 implies that the optimality of a solution will be determined by the partition of a single curve. The minimum radius of a solution for a partition at $i$ of a curve $C_{j}$ under translation may be computed in constant time by finding the bounding boxes around the prefix and suffix of the curve, and the radius of the solution can then be obtained from the candidate pairs of determining and opposing vertices implied by the bounding boxes. Specifically, the value $r_{i}^{j}$ is a lower bound on the optimal radius obtained by the partition at $i$ of curve $C_{j}$, and can be computed in constant time, for example, when $S$ is below-left of $\overline{S}$:

[TABLE]

An optimal solution for $\mathcal{C}$ under translation where the squares coincide with a particular pair of opposing corners of $R$ can computed as $r:=\max_{j\colon C_{j}\in\mathcal{C}}\min_{1\leq i\leq m}r_{i}^{j}$, i.e., the minimum radius of a pair of squares covering the partition of a curve, and then determining the largest such value over all curves. The solutions are evaluated where $S$ and $\overline{S}$ coincide with each of the four ordered pairs of opposite corners of $R$, and the overall solution is the smallest of these values. We thus obtain the following result.

Theorem 17**.**

Given a set of curves $\mathcal{C}$ as input, an optimal solution to the $(1,2)$-Center problem under translation using the discrete Fréchet distance under the $L_{\infty}$ metric can be computed in $O(nm)$ time and $O(nm)$ space.

6.3 $(1,2)$-Center and $L_{2}$ metric

For the $(1,2)$-Center problem and $L_{2}$ we need some more sophisticated arguments, but again we use a similar basic approach.

We first consider the decision problem: Given a value $r>0$, determine whether there exists a segment $s$ such that $\max_{C_{i}\in\mathcal{C}}d_{dF}(s,C_{i})\leq r$.

For each curve $C\in\mathcal{C}$ and for each vertex $p$ of $C$, draw a disk of radius $r$ centered at $p$ and denote it by $D(p)$. Let $\mathcal{D}$ denote the resulting set of $nm$ disks and let $\mathcal{A}(\mathcal{D})$ be the arrangement of the disks in $\mathcal{D}$. The combinatorial complexity of $\mathcal{A}(\mathcal{D})$ is $O(n^{2}m^{2})$. Let $A$ be a cell of $\mathcal{A}(\mathcal{D})$. Then, each curve $C=(p_{1},\ldots,p_{m})\in\mathcal{C}$ induces a bit vector $V_{C}$ of length $m$; the $i$th bit of $V_{C}$ is 1 if and only if $D(p_{i})\supseteq A$. Moreover, if $j$ is the index of the first 0 in $V_{C}$, then the suffix of curve $C$ at cell $A$ is $C[j,m]$.

We maintain the vectors $V_{C}$ as we traverse the arrangement $\mathcal{A}(\mathcal{D})$, by constructing a binary tree $T_{C}$, for each curve $C$, as described in the previous section. The leaves of $T_{C}$ correspond to the vertices of $C$, and in each node we store a single bit. Here, the bit at a leaf node corresponding to vertex $p_{i}$ is 1 if and only if $D(p_{i})\supseteq A$, where $A$ is the current cell of the arrangement. For an internal node, the bit is 1 if and only if all the bits in the leaves of its subtree are 1. We can determine the current suffix of $C$ in $O(\log m)$ time, and the cost of an update operation is $O(\log m)$. We also maintain the set $P$, where $P$ is the union of the suffixes of the curves in $\mathcal{C}$, and its corresponding region $X=\cap_{p\in P}D(p)$. Actually, we only need to know whether $X$ is empty or not.

We begin by constructing the trees $T_{C_{1}},\ldots,T_{C_{n}}$ and initializing all bits to 0, which takes $O(mn)$ time. We also construct the data structures for $P$ and $X$, where initially $P=C_{1}[1,m]\cup\cdots\cup C_{n}[1,m]$. This takes $O(nm\log^{2}(nm))$ time in total. For $P$ we use a standard balanced search tree, and for $X$ we use, e.g., the data structure of Sharir [Sha97], which supports updates to $X$ in $O(\log^{2}(nm))$ time. We now traverse $\mathcal{A}(\mathcal{D})$ systematically, beginning with the unbounded cell of $\mathcal{A}(\mathcal{D})$, which is not contained in any of the disks of $\mathcal{D}$. Whenever we enter a new cell $A$ from a neighboring cell separated from it by an arrangement edge, then we either enter or exit the unique disk of $\mathcal{D}$ whose boundary contains this edge. We thus first update the corresponding tree $T_{C}$ accordingly, and redetermine the suffix of $C$. We now may need to perform $O(m)$ update operations on the data structures for $P$ and $X$, so that they correspond to the current cell. At this point, if $X\neq\emptyset$, then we halt and return yes (since we know that the minimum enclosing disk of the union of the prefixes is at most $r$). If, however, $X=\emptyset$, then we continue to the next cell of $\mathcal{A}(\mathcal{D})$, unless there is no such cell in which case we return no. We conclude that the decision problem can be solved in $O(n^{2}m^{3}\log^{2}(nm))$ time and $O(n^{2}m^{2})$ space.

Notice that the minimum radius $r^{*}$ for which the decision version returns yes, is determined by three of the $nm$ curve vertices. Thus, we perform a binary search in the (implicit) set of potential radii (whose size is $O(n^{3}m^{3})$) in order to find $r^{*}$. Each comparison in this search is resolved by solving the decision problem for the appropriate potential radius. Moreover, after resolving the current comparison, the potential radius for the next comparison can be found in $O(n^{2}m^{2}\log^{2}(nm))$ time, as in the early near-quadratic algorithms for the well-known 2-center problem, see, e.g., [AS94, JK94, KS97].

The following theorem summarizes the main result of this section.

Theorem 18**.**

Given a set of curves $\mathcal{C}$ as input, an optimal solution to the $(1,2)$-Center problem using the discrete Fréchet distance under the $L_{2}$ metric can be computed in $O(n^{2}m^{3}\log^{3}(nm))$ time and $O(n^{2}m^{2})$ space.