Searcharxiv⌕ Search

arXiv subjects

Haitao Wang

Publications and source records attributed to Haitao Wang.

At least 127 records · Page 7Linked to original sources

An Optimal Deterministic Algorithm for Geodesic Farthest-Point Voronoi Diagrams in Simple Polygons

Given a set $S$ of $m$ point sites in a simple polygon $P$ of $n$ vertices, we consider the problem of computing the geodesic farthest-point Voronoi diagram for $S$ in $P$. It is known that the problem has an $Ω(n+m\log m)$ time lower bound. Previously, a randomized algorithm was proposed [Barba, SoCG 2019] that can solve the problem in $O(n+m\log m)$ expected time. The previous best deterministic algorithms solve the problem in $O(n\log \log n+ m\log m)$ time [Oh, Barba, and Ahn, SoCG 2016] or in $O(n+m\log m+m\log^2 n)$ time [Oh and Ahn, SoCG 2017]. In this paper, we present a deterministic algorithm of $O(n+m\log m)$ time, which is optimal. This answers an open question posed by Mitchell in the Handbook of Computational Geometry two decades ago.

cs.CG↗

Algorithms for the Line-Constrained Disk Coverage and Related Problems

Given a set $P$ of $n$ points and a set $S$ of $m$ weighted disks in the plane, the disk coverage problem asks for a subset of disks of minimum total weight that cover all points of $P$. The problem is NP-hard. In this paper, we consider a line-constrained version in which all disks are centered on a line $L$ (while points of $P$ can be anywhere in the plane). We present an $O((m+n)\log(m+n)+κ\log m)$ time algorithm for the problem, where $κ$ is the number of pairs of disks that intersect. Alternatively, we can also solve the problem in $O(nm\log(m+n))$ time. For the unit-disk case where all disks have the same radius, the running time can be reduced to $O((n+m)\log(m+n))$. In addition, we solve in $O((m+n)\log(m+n))$ time the $L_{\infty}$ and $L_1$ cases of the problem, in which the disks are squares and diamonds, respectively. As a by-product, the 1D version of the problem where all points of $P$ are on $L$ and the disks are line segments on $L$ is also solved in $O((m+n)\log(m+n))$ time. We also show that the problem has an $Ω((m+n)\log (m+n))$ time lower bound even for the 1D case. We further demonstrate that our techniques can also be used to solve other geometric coverage problems. For example, given in the plane a set $P$ of $n$ points and a set $S$ of $n$ weighted half-planes, we solve in $O(n^4\log n)$ time the problem of finding a subset of half-planes to cover $P$ so that their total weight is minimized. This improves the previous best algorithm of $O(n^5)$ time by almost a linear factor. If all half-planes are lower ones, then our algorithm runs in $O(n^2\log n)$ time, which improves the previous best algorithm of $O(n^4)$ time by almost a quadratic factor.

cs.CG↗

A New Algorithm for Euclidean Shortest Paths in the Plane

Given a set of pairwise disjoint polygonal obstacles in the plane, finding an obstacle-avoiding Euclidean shortest path between two points is a classical problem in computational geometry and has been studied extensively. Previously, Hershberger and Suri [SIAM J. Comput. 1999] gave an algorithm of $O(n\log n)$ time and $O(n\log n)$ space, where $n$ is the total number of vertices of all obstacles. Recently, by modifying Hershberger and Suri's algorithm, Wang [SODA 2021] reduced the space to $O(n)$ while the runtime of the algorithm is still $O(n\log n)$. In this paper, we present a new algorithm of $O(n+h\log h)$ time and $O(n)$ space, provided that a triangulation of the free space is given, where $h$ is the number of obstacles. The algorithm, which improves the previous work when $h=o(n)$, is optimal in both time and space as $Ω(n+h\log h)$ is a lower bound on the runtime. Our algorithm builds a shortest path map for a source point $s$, so that given any query point $t$, the shortest path length from $s$ to $t$ can be computed in $O(\log n)$ time and a shortest $s$-$t$ path can be produced in additional time linear in the number of edges of the path.

cs.CG↗

Algorithms for Diameters of Unicycle Graphs and Diameter-Optimally Augmenting Trees

We consider the problem of computing the diameter of a unicycle graph (i.e., a graph with a unique cycle). We present an O(n) time algorithm for the problem, where n is the number of vertices of the graph. This improves the previous best O(n \log n) time solution [Oh and Ahn, ISAAC 2016]. Using this algorithm as a subroutine, we solve the problem of adding a shortcut to a tree so that the diameter of the new graph (which is a unicycle graph) is minimized; our algorithm takes O(n^2 \log n) time and O(n) space. The previous best algorithms solve the problem in O(n^2 \log^3 n) time and O(n) space [Oh and Ahn, ISAAC 2016], or in O(n^2) time and O(n^2) space [Bilò, ISAAC 2018].

cs.DS↗

Towards Accurate and Consistent Evaluation: A Dataset for Distantly-Supervised Relation Extraction

In recent years, distantly-supervised relation extraction has achieved a certain success by using deep neural networks. Distant Supervision (DS) can automatically generate large-scale annotated data by aligning entity pairs from Knowledge Bases (KB) to sentences. However, these DS-generated datasets inevitably have wrong labels that result in incorrect evaluation scores during testing, which may mislead the researchers. To solve this problem, we build a new dataset NYTH, where we use the DS-generated data as training data and hire annotators to label test data. Compared with the previous datasets, NYT-H has a much larger test set and then we can perform more accurate and consistent evaluation. Finally, we present the experimental results of several widely used systems on NYT-H. The experimental results show that the ranking lists of the comparison systems on the DS-labelled test data and human-annotated test data are different. This indicates that our human-annotated data is necessary for evaluation of distantly-supervised relation extraction.

cs.CL↗

A Linear-Time Algorithm for Discrete Radius Optimally Augmenting Paths in a Metric Space

Let $P$ be a path graph of $n$ vertices embedded in a metric space. We consider the problem of adding a new edge to $P$ so that the radius of the resulting graph is minimized, where any center is constrained to be one of the vertices of $P$. Previously, the "continuous" version of the problem where a center may be a point in the interior of an edge of the graph was studied and a linear-time algorithm was known. Our "discrete" version of the problem has not been studied before. We present a linear-time algorithm for the problem.

cs.DS↗

Overview of the CCKS 2019 Knowledge Graph Evaluation Track: Entity, Relation, Event and QA

Knowledge graph models world knowledge as concepts, entities, and the relationships between them, which has been widely used in many real-world tasks. CCKS 2019 held an evaluation track with 6 tasks and attracted more than 1,600 teams. In this paper, we give an overview of the knowledge graph evaluation tract at CCKS 2019. By reviewing the task definition, successful methods, useful resources, good strategies and research challenges associated with each task in CCKS 2019, this paper can provide a helpful reference for developing knowledge graph applications and conducting future knowledge graph researches.

cs.AI↗

Algorithms for Subpath Convex Hull Queries and Ray-Shooting Among Segments

In this paper, we first consider the subpath convex hull query problem: Given a simple path $π$ of $n$ vertices, preprocess it so that the convex hull of any query subpath of $π$ can be quickly obtained. Previously, Guibas, Hershberger, and Snoeyink [SODA 90'] proposed a data structure of $O(n)$ space and $O(\log n\log\log n)$ query time; reducing the query time to $O(\log n)$ increases the space to $O(n\log\log n)$. We present an improved result that uses $O(n)$ space while achieving $O(\log n)$ query time. Like the previous work, our query algorithm returns a compact interval tree representing the convex hull so that standard binary-search-based queries on the hull can be performed in $O(\log n)$ time each. Our new result leads to improvements for several other problems. In particular, with the help of the above result, we present new algorithms for the ray-shooting problem among segments. Given a set of $n$ (possibly intersecting) line segments in the plane, preprocess it so that the first segment hit by a query ray can be quickly found. We give a data structure of $O(n\log n)$ space that can answer each query in $(\sqrt{n}\log n)$ time. If the segments are nonintersecting or if the segments are lines, then the space can be reduced to $O(n)$. All these are classical problems that have been studied extensively. Previously data structures of $\widetilde{O}(\sqrt{n})$ query time (the notation $\widetilde{O}$ suppresses a polylogarithmic factor) were known in early 1990s; nearly no progress has been made for over two decades. For all problems, our results provide improvements by reducing the space of the data structures by at least a logarithmic factor while the preprocessing and query times are the same as before or even better.

cs.CG↗

On the Planar Two-Center Problem and Circular Hulls

Given a set $S$ of $n$ points in the Euclidean plane, the two-center problem is to find two congruent disks of smallest radius whose union covers all points of $S$. Previously, Eppstein [SODA'97] gave a randomized algorithm of $O(n\log^2n)$ expected time and Chan [CGTA'99] presented a deterministic algorithm of $O(n\log^2 n\log^2\log n)$ time. In this paper, we propose an $O(n\log^2 n)$ time deterministic algorithm, which improves Chan's deterministic algorithm and matches the randomized bound of Eppstein. If $S$ is in convex position, then we solve the problem in $O(n\log n\log\log n)$ deterministic time. Our results rely on new techniques for dynamically maintaining circular hulls under point insertions and deletions, which are of independent interest.

cs.CG↗

CCKS 2019 Shared Task on Inter-Personal Relationship Extraction

The CCKS2019 shared task was devoted to inter-personal relationship extraction. Given two person entities and at least one sentence containing these two entities, participating teams are asked to predict the relationship between the entities according to a given relation list. This year, 358 teams from various universities and organizations participated in this task. In this paper, we present the task definition, the description of data and the evaluation methodology used during this shared task. We also present a brief overview of the various methods adopted by the participating teams. Finally, we present the evaluation results.

cs.CL↗

IPRE: a Dataset for Inter-Personal Relationship Extraction

Inter-personal relationship is the basis of human society. In order to automatically identify the relations between persons from texts, we need annotated data for training systems. However, there is a lack of a massive amount of such data so far. To address this situation, we introduce IPRE, a new dataset for inter-personal relationship extraction which aims to facilitate information extraction and knowledge graph construction research. In total, IPRE has over 41,000 labeled sentences for 34 types of relations, including about 9,000 sentences annotated by workers. Our data is the first dataset for inter-personal relationship extraction. Additionally, we define three evaluation tasks based on IPRE and provide the baseline systems for further comparison in future work.

cs.CL↗

Improved Algorithms for the Bichromatic Two-Center Problem for Pairs of Points

We consider a bichromatic two-center problem for pairs of points. Given a set $S$ of $n$ pairs of points in the plane, for every pair, we want to assign a red color to one point and a blue color to the other, in such a way that the value $\max\{r_1,r_2\}$ is minimized, where $r_1$ (resp., $r_2$) is the radius of the smallest enclosing disk of all red (resp., blue) points. Previously, an exact algorithm of $O(n^3\log^2 n)$ time and a $(1+\varepsilon)$-approximate algorithm of $O(n + (1/\varepsilon)^6 \log^2 (1/\varepsilon))$ time were known. In this paper, we propose a new exact algorithm of $O(n^2\log^2 n)$ time and a new $(1+\varepsilon)$-approximate algorithm of $O(n + (1/\varepsilon)^3 \log^2 (1/\varepsilon))$ time.

cs.CG↗

A Linear-Time Algorithm for Radius-Optimally Augmenting Paths in a Metric Space

Let $P$ be a path graph of $n$ vertices embedded in a metric space. We consider the problem of adding a new edge to $P$ to minimize the radius of the resulting graph. Previously, a similar problem for minimizing the diameter of the graph was solved in $O(n\log n)$ time. To the best of our knowledge, the problem of minimizing the radius has not been studied before. In this paper, we present an $O(n)$ time algorithm for the problem, which is optimal.

cs.DS↗

Near-Optimal Algorithms for Shortest Paths in Weighted Unit-Disk Graphs

We revisit a classical graph-theoretic problem, the \textit{single-source shortest-path} (SSSP) problem, in weighted unit-disk graphs. We first propose an exact (and deterministic) algorithm which solves the problem in $O(n \log^2 n)$ time using linear space, where $n$ is the number of the vertices of the graph. This significantly improves the previous deterministic algorithm by Cabello and Jejčič [CGTA'15] which uses $O(n^{1+δ})$ time and $O(n^{1+δ})$ space (for any small constant $δ>0$) and the previous randomized algorithm by Kaplan et al. [SODA'17] which uses $O(n \log^{12+o(1)} n)$ expected time and $O(n \log^3 n)$ space. More specifically, we show that if the 2D offline insertion-only (additively-)weighted nearest-neighbor problem with $k$ operations (i.e., insertions and queries) can be solved in $f(k)$ time, then the SSSP problem in weighted unit-disk graphs can be solved in $O(n \log n+f(n))$ time. Using the same framework with some new ideas, we also obtain a $(1+\varepsilon)$-approximate algorithm for the problem, using $O(n \log n + n \log^2(1/\varepsilon))$ time and linear space. This improves the previous $(1+\varepsilon)$-approximate algorithm by Chan and Skrepetos [SoCG'18] which uses $O((1/\varepsilon)^2 n \log n)$ time and $O((1/\varepsilon)^2 n)$ space. More specifically, we show that if the 2D offline insertion-only weighted nearest-neighbor problem with $k_1$ operations in which at most $k_2$ operations are insertions can be solved in $f(k_1,k_2)$ time, then the $(1+\varepsilon)$-approximate SSSP problem in weighted unit-disk graphs can be solved in $O(n \log n+f(n,O(\varepsilon^{-2})))$ time. Because of the $Ω(n \log n)$-time lower bound of the problem (even when approximation is allowed), both of our algorithms are almost optimal.

cs.CG↗

A Divide-and-Conquer Algorithm for Two-Point $L_1$ Shortest Path Queries in Polygonal Domains

Let $\mathcal{P}$ be a polygonal domain of $h$ holes and $n$ vertices. We study the problem of constructing a data structure that can compute a shortest path between $s$ and $t$ in $\mathcal{P}$ under the $L_1$ metric for any two query points $s$ and $t$. To do so, a standard approach is to first find a set of $n_s$ "gateways" for $s$ and a set of $n_t$ "gateways" for $t$ such that there exist a shortest $s$-$t$ path containing a gateway of $s$ and a gateway of $t$, and then compute a shortest $s$-$t$ path using these gateways. Previous algorithms all take quadratic $O(n_s\cdot n_t)$ time to solve this problem. In this paper, we propose a divide-and-conquer technique that solves the problem in $O(n_s + n_t \log n_s)$ time. As a consequence, we construct a data structure of $O(n+(h^2\log^3 h/\log\log h))$ size in $O(n+(h^2\log^4 h/\log\log h))$ time such that each query can be answered in $O(\log n)$ time.

cs.CG↗

Explicit Structure of the Fokker-Planck Equation with potential

We study the pointwise (in the space and time variables) behavior of the Fokker-Planck Equation with flat confinement. The solution has very clear description in the $xt-$plane, including large time behavior, initial layer and asymptotic behavior. Moreover, the structure of the solution highly depends on the potential function.

math-ph↗

$L_1$ Shortest Path Queries in Simple Polygons

Let $P$ be a simple polygon of $n$ vertices. We consider two-point $L_1$ shortest path queries in $P$. We build a data structure of $O(n)$ size in $O(n)$ time such that given any two query points $s$ and $t$, the length of an $L_1$ shortest path from $s$ to $t$ in $P$ can be computed in $O(\log n)$ time, or in $O(1)$ time if both $s$ and $t$ are vertices of $P$, and an actual shortest path can be output in additional linear time in the number of edges of the path. To achieve the result, we propose a mountain decomposition of simple polygons, which may be interesting in its own right. Most importantly, our approach is much simpler than the previous work on this problem.

cs.CG↗

Algorithms for Covering Multiple Barriers

In this paper, we consider the problems for covering multiple intervals on a line. Given a set $B$ of $m$ line segments (called "barriers") on a horizontal line $L$ and another set $S$ of $n$ horizontal line segments of the same length in the plane, we want to move all segments of $S$ to $L$ so that their union covers all barriers and the maximum movement of all segments of $S$ is minimized. Previously, an $O(n^3\log n)$-time algorithm was given for the case $m=1$. In this paper, we propose an $O(n^2\log n\log \log n+nm\log m)$-time algorithm for a more general setting with any $m\geq 1$, which also improves the previous work when $m=1$. We then consider a line-constrained version of the problem in which the segments of $S$ are all initially on the line $L$. Previously, an $O(n\log n)$-time algorithm was known for the case $m=1$. We present an algorithm of $O(m\log m+n\log m \log n)$ time for any $m\geq 1$. These problems may have applications in mobile sensor barrier coverage in wireless sensor networks.

cs.CG↗