scholarly journals Agglomerative Clustering of Growing Squares

Algorithmica ◽  
2021 ◽  
Author(s):  
Thom Castermans ◽  
Bettina Speckmann ◽  
Frank Staals ◽  
Kevin Verbeek
Keyword(s):  
Data Structure ◽  
Kinetic Data ◽  
Time Algorithm ◽  
Agglomerative Clustering ◽  
Worst Case ◽  
Kinetic Data Structure ◽  
Clustering Problem ◽  
Interactive Map

AbstractWe study an agglomerative clustering problem motivated by interactive glyphs in geo-visualization. Consider a set of disjoint square glyphs on an interactive map. When the user zooms out, the glyphs grow in size relative to the map, possibly with different speeds. When two glyphs intersect, we wish to replace them by a new glyph that captures the information of the intersecting glyphs. We present a fully dynamic kinetic data structure that maintains a set of n disjoint growing squares. Our data structure uses $$O\bigl (n \log n \log \log n\bigr )$$ O ( n log n log log n ) space, supports queries in worst case $$O\bigl (\log ^2 n\bigr )$$ O ( log 2 n ) time, and updates in $$O\bigl (\log ^5 n\bigr )$$ O ( log 5 n ) amortized time. This leads to an $$O\bigl (n\,\alpha (n)\log ^5 n\bigr )$$ O ( n α ( n ) log 5 n ) time algorithm to solve the agglomerative clustering problem. This is a significant improvement over the current best $$O\bigl (n^2\bigr )$$ O ( n 2 ) time algorithms.

KINETIC COLLISION DETECTION FOR SIMPLE POLYGONS

2002 ◽  
Vol 12 (01n02) ◽  
pp. 3-27 ◽  
Author(s):  
DAVID KIRKPATRICK ◽  
JACK SNOEYINK ◽  
BETTINA SPECKMANN
Keyword(s):  
Data Structure ◽  
Collision Detection ◽  
Kinetic Data ◽  
Minimum Size ◽  
Active Set ◽  
Worst Case ◽  
Kinetic Data Structure ◽  
External Events ◽  
Definition Of ◽  
Case Number

We design a simple and elegant kinetic data structure for detecting collisions between polygonal (but not necessarily convex) objects in motion in the plane. Our structure is compact, maintaining an active set of certificates whose number is proportional to a minimum-size set of separating polygons for the objects. It is also responsive; on the failure of a certificate invariants can be restored in time logarithmic in the total number of object vertices. It is difficult to characterize the efficiency of our structure for lack of a canonical definition of external events. Nevertheless we give an easy upper bound on the worst case number of certificate failures.

scholarly journals A soft kinetic data structure for lesion border detection

2010 ◽  
Vol 26 (12) ◽  
pp. i21-i28 ◽  
Author(s):  
S. Kockara ◽  
M. Mete ◽  
V. Yip ◽  
B. Lee ◽  
K. Aydin
Keyword(s):  
Data Structure ◽  
Kinetic Data ◽  
Border Detection ◽  
Kinetic Data Structure

scholarly journals Optimal Purely Functional Priority Queues

1996 ◽  
Vol 3 (37) ◽  
Author(s):  
Gerth Stølting Brodal ◽  
Chris Okasaki
Keyword(s):  
Data Structure ◽  
Higher Order ◽  
Priority Queues ◽  
Worst Case ◽  
Minimum Element ◽  
Asymptotically Optimal ◽  
Running Time ◽  
Recursive Structures ◽  
Functional Setting

Brodal recently introduced the first implementation of imperative priority queues to support findMin, insert, and meld in O(1) worst-case time, and deleteMin in O(log n) worst-case time. These bounds are asymptotically optimal among all comparison-based priority queues. In this paper, we adapt<br />Brodal's data structure to a purely functional setting. In doing so, we both simplify the data structure and clarify its relationship to the binomial queues of Vuillemin, which support all four operations in O(log n) time. Specifically, we derive our implementation from binomial queues in three steps: first, we reduce the running time of insert to O(1) by eliminating the possibility of cascading links; second, we reduce the running time of findMin to O(1) by adding a global root to hold the minimum element; and finally, we reduce the running time of meld to O(1) by allowing priority queues to contain other<br />priority queues. Each of these steps is expressed using ML-style functors. The last transformation, known as data-structural bootstrapping, is an interesting<br />application of higher-order functors and recursive structures.

scholarly journals Results on a Super Strong Exponential Time Hypothesis

2020 ◽  
Vol 34 (09) ◽  
pp. 13700-13703
Author(s):  
Nikhil Vyas ◽  
Ryan Williams
Keyword(s):  
Randomized Algorithm ◽  
Time Algorithm ◽  
Critical Threshold ◽  
Polynomial Method ◽  
Variable Ratio ◽  
Sat Solving ◽  
Worst Case ◽  
Exponential Time ◽  
Exponential Time Hypothesis ◽  
Special Case

All known SAT-solving paradigms (backtracking, local search, and the polynomial method) only yield a 2n(1−1/O(k)) time algorithm for solving k-SAT in the worst case, where the big-O constant is independent of k. For this reason, it has been hypothesized that k-SAT cannot be solved in worst-case 2n(1−f(k)/k) time, for any unbounded ƒ : ℕ → ℕ. This hypothesis has been called the “Super-Strong Exponential Time Hypothesis” (Super Strong ETH), modeled after the ETH and the Strong ETH. We prove two results concerning the Super-Strong ETH:1. It has also been hypothesized that k-SAT is hard to solve for randomly chosen instances near the “critical threshold”, where the clause-to-variable ratio is 2k ln 2 −Θ(1). We give a randomized algorithm which refutes the Super-Strong ETH for the case of random k-SAT and planted k-SAT for any clause-to-variable ratio. In particular, given any random k-SAT instance F with n variables and m clauses, our algorithm decides satisfiability for F in 2n(1−Ω( log k)/k) time, with high probability (over the choice of the formula and the randomness of the algorithm). It turns out that a well-known algorithm from the literature on SAT algorithms does the job: the PPZ algorithm of Paturi, Pudlak, and Zane (1998).2. The Unique k-SAT problem is the special case where there is at most one satisfying assignment. It is natural to hypothesize that the worst-case (exponential-time) complexity of Unique k-SAT is substantially less than that of k-SAT. Improving prior reductions, we show the time complexities of Unique k-SAT and k-SAT are very tightly related: if Unique k-SAT is in 2n(1−f(k)/k) time for an unbounded f, then k-SAT is in 2n(1−f(k)(1−ɛ)/k) time for every ɛ > 0. Thus, refuting Super Strong ETH in the unique solution case would refute Super Strong ETH in general.

ENFORCEMENT OF INTER-TASK DEPENDENCIES IN WORKFLOWS, CHARACTERIZATION AND PARADIGM

1998 ◽  
Vol 07 (01) ◽  
pp. 19-53 ◽  
Author(s):  
JIAN TANG ◽  
JARI VEIJALAINEN
Keyword(s):  
Data Structure ◽  
Information Systems ◽  
Time Algorithm ◽  
The Other ◽  
Legacy Systems ◽  
Event Sequences ◽  
Business Applications ◽  
Valuable Method ◽  
Run Time ◽  
Original Approach

Workflow techniques have gained a lot of attention as a means to support advanced business applications such as cooperative information systems and process re-engineering but also as a means to integrate legacy systems. Inter-task dependencies, described separately from the other parts of the workflow, have been recognized as a valuable method in describing certain restrictions on the executions of workflows. In this paper, we study the issue of pre-analysing and enforcing inter-task dependencies. The protocol and the theory behind it are presented, along with examples and discussions on ways to improve the performance. The idea is to present the meaning of a dependency through an automaton which accepts the sequences of events tied by the dependency through an automaton which accepts the sequences of events tied by the dependency. We prune from the automata certain paths that cannot be followed due to the conflicting paths in other automata and record the feasible event sequences in a special data structure to be used during run-time. We show the correctness of the algorithms and also show that our run-time algorithm is linear, whereas the original approach suggested by MCC in Refs. 5 and 6 is exponential, when resolution of one event is concerned.

THE EDIT-DISTANCE BETWEEN A REGULAR LANGUAGE AND A CONTEXT-FREE LANGUAGE

2013 ◽  
Vol 24 (07) ◽  
pp. 1067-1082 ◽  
Author(s):  
YO-SUB HAN ◽  
SANG-KI KO ◽  
KAI SALOMAA
Keyword(s):  
Regular Language ◽  
Edit Distance ◽  
Polynomial Time Algorithm ◽  
Time Algorithm ◽  
The Other ◽  
Optimal Alignment ◽  
Worst Case ◽  
Context Free Language ◽  
Context Free ◽  
Free Language

The edit-distance between two strings is the smallest number of operations required to transform one string into the other. The distance between languages L1and L2is the smallest edit-distance between string wi∈ Li, i = 1, 2. We consider the problem of computing the edit-distance of a given regular language and a given context-free language. First, we present an algorithm that finds for the languages an optimal alignment, that is, a sequence of edit operations that transforms a string in one language to a string in the other. The length of the optimal alignment, in the worst case, is exponential in the size of the given grammar and finite automaton. Then, we investigate the problem of computing only the edit-distance of the languages without explicitly producing an optimal alignment. We design a polynomial time algorithm that calculates the edit-distance based on unary homomorphisms.

scholarly journals Fast Fréchet Distance Between Curves with Long Edges

2019 ◽  
Vol 29 (02) ◽  
pp. 161-187
Author(s):  
Joachim Gudmundsson ◽  
Majid Mirzanezhad ◽  
Ali Mohades ◽  
Carola Wenk
Keyword(s):  
Data Structure ◽  
Approximation Algorithm ◽  
Special Class ◽  
Linear Time ◽  
Time Algorithm ◽  
Linear Time Algorithm ◽  
Fréchet Distance ◽  
Frechet Distance ◽  
Polygonal Curves

Computing the Fréchet distance between two polygonal curves takes roughly quadratic time. In this paper, we show that for a special class of curves the Fréchet distance computations become easier. Let [Formula: see text] and [Formula: see text] be two polygonal curves in [Formula: see text] with [Formula: see text] and [Formula: see text] vertices, respectively. We prove four results for the case when all edges of both curves are long compared to the Fréchet distance between them: (1) a linear-time algorithm for deciding the Fréchet distance between two curves, (2) an algorithm that computes the Fréchet distance in [Formula: see text] time, (3) a linear-time [Formula: see text]-approximation algorithm, and (4) a data structure that supports [Formula: see text]-time decision queries, where [Formula: see text] is the number of vertices of the query curve and [Formula: see text] the number of vertices of the preprocessed curve.

scholarly journals Encoding range minima and range top-2 queries

2014 ◽  
Vol 372 (2016) ◽  
pp. 20130131 ◽  
Author(s):  
Pooya Davoodi ◽  
Gonzalo Navarro ◽  
Rajeev Raman ◽  
S. Srinivasa Rao
Keyword(s):  
Data Structure ◽  
Lower Bounds ◽  
Query Time ◽  
Constant Time ◽  
Worst Case ◽  
Asymptotically Optimal ◽  
Random Array ◽  
Case Data ◽  
Natural Way

We consider the problem of encoding range minimum queries (RMQs): given an array A [1.. n ] of distinct totally ordered values, to pre-process A and create a data structure that can answer the query RMQ( i , j ), which returns the index containing the smallest element in A [ i .. j ], without access to the array A at query time. We give a data structure whose space usage is 2 n + o ( n ) bits, which is asymptotically optimal for worst-case data, and answers RMQs in O (1) worst-case time. This matches the previous result of Fischer and Heun, but is obtained in a more natural way. Furthermore, our result can encode the RMQs of a random array A in 1.919 n + o ( n ) bits in expectation, which is not known to hold for Fischer and Heun’s result. We then generalize our result to the encoding range top-2 query (RT2Q) problem, which is like the encoding RMQ problem except that the query RT2Q( i , j ) returns the indices of both the smallest and second smallest elements of A [ i .. j ]. We introduce a data structure using 3.272 n + o ( n ) bits that answers RT2Qs in constant time, and also give lower bounds on the effective entropy of the RT2Q problem.

scholarly journals COMPUTING SIGNED PERMUTATIONS OF POLYGONS

2011 ◽  
Vol 21 (01) ◽  
pp. 87-100
Author(s):  
GREG ALOUPIS ◽  
PROSENJIT BOSE ◽  
ERIK D. DEMAINE ◽  
STEFAN LANGERMAN ◽  
HENK MEIJER ◽  
...  
Keyword(s):  
Mirror Symmetry ◽  
Time Algorithm ◽  
Worst Case ◽  
Signed Permutations ◽  
Np Complete ◽  
Edge List ◽  
The Given ◽  
Special Case ◽  
Planar Polygon

Given a planar polygon (or chain) with a list of edges {e1, e2, e3, …, en-1, en}, we examine the effect of several operations that permute this edge list, resulting in the formation of a new polygon. The main operations that we consider are: reversals which involve inverting the order of a sublist, transpositions which involve interchanging subchains (sublists), and edge-swaps which are a special case and involve interchanging two consecutive edges. When each edge of the given polygon has also been assigned a direction we say that the polygon is signed. In this case any edge involved in a reversal changes direction. We show that a star-shaped polygon can be convexified using O(n2) edge-swaps, while maintaining simplicity, and that this is tight in the worst case. We show that determining whether a signed polygon P can be transformed to one that has rotational or mirror symmetry with P, using transpositions, takes Θ(n log n) time. We prove that the problem of deciding whether transpositions can modify a polygon to fit inside a rectangle is weakly NP-complete. Finally we give an O(n log n) time algorithm to compute the maximum endpoint distance for an oriented chain.

Sign in / Sign up

Export Citation Format

Share Document