Data Structure Of Size Research Articles

Robust Proximity Search for Balls Using Sublinear Space

Given a set of n disjoint balls $$b_1, \dots , b_n$$ in $$\mathrm{I\! R}^d$$ , we provide a data structure of near linear size that can answer $$(1\pm {\varepsilon })$$ -approximate kth-nearest neighbor queries on the balls in $$O(\log n + 1/{\varepsilon }^d)$$ time, where k and $${\varepsilon }$$ may be provided at query time. If k and $${\varepsilon }$$ are provided in advance, we provide a data structure to answer such queries requiring O(n / k) space; that is, the data structure requires sublinear space if k is sufficiently large.

The Size of BDDs and Other Data Structures in Temporal Logics Model Checking

Temporal Logic Model Checking is a verification method in which we describe a system, the model, and then we verify whether some properties, expressed in a temporal logic formula, hold in the system. It has many industrial applications. In order to improve performance, some tools allow preprocessing of the model, verifying on-line a set of properties reusing the same compiled model; we prove that the complexity of the Model Checking problem, without any preprocessing or preprocessing the model or the formula in a polynomial data structure, is the same. As a result preprocessing does not always exponentially improve performance. Symbolic Model Checking algorithms work by manipulating sets of states, and these sets are often represented by BDDs. It has been observed that the size of BDDs may grow exponentially as the model and formula increase in size. As a side result, we formally prove that a superpolynomial increase of the size of these BDDs is unavoidable in the worst case. While this exponential growth has been empirically observed, to the best of our knowledge it has never been proved so far in general terms. This result not only holds for all types of BDDs regardless of the variable ordering, but also for more powerful data structures, such as BEDs, RBCs, MTBDDs, and ADDs.

A type theory for incremental computational complexity with control flow changes

Incremental computation aims to speed up re-runs of a program after its inputs have been modified slightly. It works by recording a trace of the program's first run and propagating changes through the trace in incremental runs, trying to re-use as much of the original trace as possible. The recent work CostIt is a type and effect system to establish the time complexity of incremental runs of a program, as a function of input changes. However, CostIt is limited in two ways. First, it prohibits input changes that influence control flow. This makes it impossible to type programs that, for instance, branch on inputs that may change. Second, the soundness of CostIt is proved relative to an abstract cost semantics, but it is unclear how the semantics can be realized. In this paper, we address both these limitations. We present DuCostIt, a re-design of CostIt, that combines reasoning about costs of change propagation and costs of from-scratch evaluation. The latter lifts the restriction on control flow changes. To obtain the type system, we refine Flow Caml, a type system for information flow analysis, with cost effects. Additionally, we inherit from CostIt index refinements to track data structure sizes and a co-monadic type. Using a combination of binary and unary step-indexed logical relations, we prove DuCostIt's cost analysis sound relative to not only an abstract cost semantics, but also a concrete semantics, which is obtained by translation to an ML-like language.

Quantum lower bound for inverting a permutation with advice

Given a random permutation $f: [N] \to [N]$ as a black box and $y \in [N]$, we want to output $x = f^{-1}(y)$. Supplementary to our input, we are given classical advice in the form of a pre-computed data structure; this advice can depend on the permutation but \emph{not} on the input $y$. Classically, there is a data structure of size $\tilde{O}(S)$ and an algorithm that with the help of the data structure, given $f(x)$, can invert $f$ in time $\tilde{O}(T)$, for every choice of parameters $S$, $T$, such that $S\cdot T \ge N$. We prove a quantum lower bound of $T^2\cdot S = \tilde{\Omega}(\eps N)$ for quantum algorithms that invert a random permutation $f$ on an $\eps$ fraction of inputs, where $T$ is the number of queries to $f$ and $S$ is the amount of advice. This answers an open question of De et al. We also give a $\Omega(\sqrt{N/m})$ quantum lower bound for the simpler but related Yao's box problem, which is the problem of recovering a bit $x_j$, given the ability to query an $N$-bit string $x$ at any index except the $j$-th, and also given $m$ bits of classical advice that depend on $x$ but not on $j$.

Weak visibility counting in simple polygons

For a simple polygon P of size n, we define weak visibility counting problem (WVCP) as finding the number of visible segments of P from a query line segment pq. We present different algorithms to compute WVCP in sub-linear time. In our first algorithm, we spend O(n7) time to preprocess the polygon and build a data structure of size O(n6), so that we can optimally answer WVCP in O(logn) time. Then, we reduce the preprocessing costs to O(n4+ϵ) time and space at the expense of more query time of O(log5n). We also obtain a trade-off between preprocessing and query time costs. Finally, we propose an approximation method to reduce the preprocessing costs to O(n2) time and space and O(n1/2+ϵ) query time.

Finding the largest disk containing a query point in logarithmic time with linear storage

Let D be a set of n disks in the plane. We present a data structure of size O ( n ) that can compute, for any query point q , the largest disk in D that contains q , in O (log n ) time. The structure can be constructed in O ( n log 3 n ) time. The optimal storage and query time of the structure improve several recent results on this and related problems

Analysis of pattern overlaps and exact computation of P-values of pattern occurrences numbers: case of Hidden Markov Models.

BackgroundFinding new functional fragments in biological sequences is a challenging problem. Methods addressing this problem commonly search for clusters of pattern occurrences that are statistically significant. A measure of statistical significance is the P-value of a number of pattern occurrences, i.e. the probability to find at least S occurrences of words from a pattern in a random text of length N generated according to a given probability model. All words of the pattern are supposed to be of same length.ResultsWe present a novel algorithm SufPref that computes an exact P-value for Hidden Markov models (HMM). The algorithm is based on recursive equations on text sets related to pattern occurrences; the equations can be used for any probability model. The algorithm inductively traverses a specific data structure, an overlap graph. The nodes of the graph are associated with the overlaps of words from . The edges are associated to the prefix and suffix relations between overlaps. An originality of our data structure is that pattern need not be explicitly represented in nodes or leaves. The algorithm relies on the Cartesian product of the overlap graph and the graph of HMM states; this approach is analogous to the automaton approach from JBCB 4: 553-569. The gain in size of SufPref data structure leads to significant improvements in space and time complexity compared to existent algorithms. The algorithm SufPref was implemented as a C++ program; the program can be used both as Web-server and a stand alone program for Linux and Windows. The program interface admits special formats to describe probability models of various types (HMM, Bernoulli, Markov); a pattern can be described with a list of words, a PSSM, a degenerate pattern or a word and a number of mismatches. It is available at http://server2.lpm.org.ru/bio/online/sf/. The program was applied to compare sensitivity and specificity of methods for TFBS prediction based on P-values computed for Bernoulli models, Markov models of orders one and two and HMMs. The experiments show that the methods have approximately the same qualities.Electronic supplementary materialThe online version of this article (doi:10.1186/s13015-014-0025-1) contains supplementary material, which is available to authorized users.

ALGORITHMS FOR DISTANCE PROBLEMS IN PLANAR COMPLEXES OF GLOBAL NONPOSITIVE CURVATURE

CAT(0) metric spaces and hyperbolic spaces play an important role in combinatorial and geometric group theory. In this paper, we present efficient algorithms for distance problems in CAT(0) planar complexes. First of all, we present an algorithm for answering single-point distance queries in a CAT(0) planar complex. Namely, we show that for a CAT(0) planar complex [Formula: see text] with n vertices, one can construct in O(n2 log n) time a data structure [Formula: see text] of size O(n2) so that, given a point [Formula: see text], the shortest path γ(x, y) between x and the query point y can be computed in linear time. Our second algorithm computes the convex hull of a finite set of points in a CAT(0) planar complex. This algorithm is based on Toussaint's algorithm for computing the convex hull of a finite set of points in a simple polygon and it constructs the convex hull of a set of k points in O(n2 log n + nk log k) time, using a data structure of size O(n2 + k).

Quickest path queries on transportation network

This paper considers the problem of finding the cost of a quickest path between two points in the Euclidean plane in the presence of a transportation network. A transportation network consists of a planar network where each road (edge) has an individual speed. A traveler may enter and exit the network at any point on the roads. Along any road the traveler moves with a fixed speed depending on the road, and outside the network the traveler moves at unit speed in any direction.We show how the transportation network with n edges in the Euclidean plane can be preprocessed in time O((nε)2logn) into a data structure of size O((nε)2) such that (1+ε)-approximate quickest path cost queries between any two points in the plane can be answered in time O(1ε4logn).In addition we consider the nearest neighbor problem in a transportation network: given a transportation network with n edges in the Euclidean plane together with a set Z of m sites, a query point q∈R2, find the nearest site in Z from q. We show how the transportation network can be preprocessed in time O((n2+nm)log(n+m)) such that (1+ε)-nearest neighbor query can be answered in time O(1ε2log(n+m)).

On reporting the [formula omitted] metric closest pair in a query rectangle

In this work, we consider the problem of finding the closest pair (in L1 metric) of points in an orthogonal query rectangle. Given a set of n static points on a U×U grid, we preprocess these points into a data structure of size O(mf(m)log2m) that can be queried in time O((g(m)+loglogm)log3m), for m=O(nlogU) and (i) f(m)=O(1) and g(m)=O(logεm); (ii) f(m)=O(loglogm) and g(m)=O(loglogm); (iii) f(m)=O(logεm) and g(m)=O(1). Here ε: 0<ε<1 is a small but arbitrary constant.

Formal modeling and analysis of resource management for cloud architectures: an industrial case study using Real-Time ABS

We demonstrate by a case study of an industrial distributed system how performance, resource consumption, and deployment on the cloud can be formally modeled and analyzed using the abstract behavioral specification language Real-Time ABS. These non-functional aspects of the system are integrated with an existing formal model of the functional system behavior, achieving a separation of concerns between the functional and non-functional aspects in the integrated model. The resource costs associated with execution in the system depend on the size of local data structures, which evolve over time; we derive corresponding worst-case cost estimations by static analysis techniques and integrate them into our resource-sensitive model. The model is further parameterized with respect to deployment scenarios which capture different application-level management policies for virtualized resources. The model is validated against the existing system's performance characteristics and used to simulate, analyze, and compare deployment scenarios on the cloud.

Preprocess, Set, Query!

Thorup and Zwick (J. ACM 52(1):1–24, 2005 and STOC’01) in their seminal work introduced the notion of distance oracles. Given an n-vertex weighted undirected graph with m edges, they show that for any integer k≥1 it is possible to preprocess the graph in $\tilde {O}(mn^{1/k})$ time and generate a compact data structure of size O(kn 1+1/k ). For each pair of vertices, it is then possible to retrieve an estimated distance with multiplicative stretch 2k−1 in O(k) time. For k=2 this gives an oracle of O(n 1.5) size that produces in constant time estimated distances with stretch 3. Recently, Pǎtrascu and Roditty (In: Proc. of 51st FOCS, 2010) broke the theoretical status-quo in the field of distance oracles and obtained a distance oracle for sparse unweighted graphs of O(n 5/3) size that produces in constant time estimated distances with stretch 2. In this paper we show that it is possible to break the stretch 2 barrier at the price of non-constant query time in unweighted undirected graphs. We present a data structure that produces estimated distances with 1+e stretch. The size of the data structure is O(nm 1−e′) and the query time is $\tilde {O}(m^{1-\varepsilon '})$ . Using it for sparse unweighted graphs we can get a data structure of size O(n 1.87) that can supply in O(n 0.87) time estimated distances with multiplicative stretch 1.75.

The compilability framework

Several problems in AI can be structured in two parts based on the nature of their data, being it fixed or varying. As an example, in automated planning an instance is made of the actions that can be performed and the specific initial state and goal; given a domain of application, the actions will stay the same, while over time planning may be required to be performed several time with differing initial and final states. The compilability classes formalize the complexity of such problems, and can also be used to establish the relative size of certain data structures and the space efficiency of knowledge representation formalisms. In this paper we review the compilability framework and its applications in various areas of Artificial Intelligence.

FlashTrie: Beyond 100-Gb/s IP Route Lookup Using Hash-Based Prefix-Compressed Trie

It is becoming apparent that the next-generation IP route lookup architecture needs to achieve speeds of 100 Gb/s and beyond while supporting IPv4 and IPv6 with fast real-time updates to accommodate ever-growing routing tables. Some of the proposed multibit-trie-based schemes, such as TreeBitmap, have been used in today's high-end routers. However, their large data structures often require multiple external memory accesses for each route lookup. A pipelining technique is widely used to achieve high-speed lookup with the cost of using many external memory chips. Pipelining also often leads to poor memory load-balancing. In this paper, we propose a new IP route lookup architecture called FlashTrie that overcomes the shortcomings of the multibit-trie-based approaches. We use a hash-based membership query to limit off-chip memory accesses per lookup and to balance memory utilization among the memory modules. By compacting the data structure size, the lookup depth of each level can be increased. We also develop a new data structure called Prefix-Compressed Trie that reduces the size of a bitmap by more than 80%. Our simulation and implementation results show that FlashTrie can achieve 80-Gb/s worst-case throughput while simultaneously supporting 2 M prefixes for IPv4 and 318 k prefixes for IPv6 with one lookup engine and two Double-Data-Rate (DDR3) SDRAM chips. When implementing five lookup engines on a state-of-the-art field programmable gate array (FPGA) chip and using 10 DDR3 memory chips, we expect FlashTrie to achieve 1-Gpps (packet per second) throughput, equivalent to 400 Gb/s for IPv4 and 600 Gb/s for IPv6. FlashTrie also supports incremental real-time updates.

Approximate Shortest Paths Avoiding a Failed Vertex: Near Optimal Data Structures for Undirected Unweighted Graphs

Let G=(V,E) be an undirected unweighted graph. A path between any two vertices u,v∈V is said to be t-approximate shortest path if its length is at most t times the length of the shortest path between u and v. We address the problem of building a compact data structure which can efficiently answer the following query for any u,v,x∈V and t>1: . We present data structures for the single source as well as all-pairs versions of this problem. The query time guaranteed by our data structures is optimal up to a constant factor. Moreover, the size of each of them nearly matches the size of the corresponding data structure with no failures.

ALGORITHMS FOR JUMBLED PATTERN MATCHING IN STRINGS

The Parikh vector p(s) of a string s over a finite ordered alphabet Σ = {a1, …, aσ} is defined as the vector of multiplicities of the characters, p(s) = (p1, …, pσ), where pi = |{j | sj = ai}|. Parikh vector q occurs in s if s has a substring t with p(t) = q. The problem of searching for a query q in a text s of length n can be solved simply and worst-case optimally with a sliding window approach in O(n) time. We present two novel algorithms for the case where the text is fixed and many queries arrive over time. The first algorithm only decides whether a given Parikh vector appears in a binary text. It uses a linear size data structure and decides each query in O(1) time. The preprocessing can be done trivially in Θ(n2) time. The second algorithm finds all occurrences of a given Parikh vector in a text over an arbitrary alphabet of size σ ≥ 2 and has sub-linear expected time complexity. More precisely, we present two variants of the algorithm, both using an O(n) size data structure, each of which can be constructed in O(n) time. The first solution is very simple and easy to implement and leads to an expected query time of [Formula: see text], where m = ∑i qi is the length of a string with Parikh vector q. The second uses wavelet trees and improves the expected runtime to [Formula: see text], i.e., by a factor of log m.

Chinese Sign Language Synthesis System on Mobile Device

In this paper, we proposed an effective approach for Chinese Sign Language (CLS) Synthesis System on mobile device. It can translate messages or other text information into Chinese sign languages in real time. In this system, it mainly includes two parts: construction of motion database and sign language synthesis based on text-driven. Construction of motion database is a prerequisite for the Chinese sign language synthesis system. Its motion quality, motion data structure and motion data size together determine the final performance of system. We also introduce a method for motion smoothing in synthesis module. We have integrated two parts on a mobile device, which can render a series of sign language motions according to specific input text from Mobile Internet.

An Efficient Approach on Object Oriented Design using Genetic Algorithm

Object oriented design is a method where developers think in terms of objects instead of procedures or functions. The overall system is designed keeping in view the interaction among objects that maintain the states and provide implementation on them. For implementing object oriented design three methodologies are adopted Object Modeling technique (OMT), Structure Analysis/Structured Design (SA/SD), Jackson Structured Design (JSD). SA/SD approach is based on the data flow and JSD approach is action-oriented. Since SA/SD is easy to understand but it focuses on well defined system boundary whereas JSD approach is too complex and does not have any graphical representation. In this paper, we will apply the concept of Genetic Algorithm to minimize the above said problem. Genetic Algorithm method is based on natural evolution. Through this algorithm, we can improve the performance of the system. Genetics Algorithm start with a fixed size of data structure which are used to perform such given task. There are basically three processes of Genetic Algorithm. 1. Crossover 2. Mutation 3. Inversion This paper presents a method to improve efficiency of Object Oriented Design. Through a method of Crossover in Genetic Algorithm, it will optimize and reduce the complexity.

Kinetic Spanners in ℝd

We present a new (1+ε)-spanner for sets of n points in ℝ d . Our spanner has size O(n/ε d−1) and maximum degree O(log d n). The main advantage of our spanner is that it can be maintained efficiently as the points move: Assuming that the trajectories of the points can be described by bounded-degree polynomials, the number of topological changes to the spanner is O(n 2/ε d−1), and using a supporting data structure of size O(nlog d n), we can handle events in time O(log d+1 n). Moreover, the spanner can be updated in time O(log n) if the flight plan of a point changes. This is the first kinetic spanner for points in ℝ d whose performance does not depend on the spread of the point set.

On Space Efficient Two Dimensional Range Minimum Data Structures

The two dimensional range minimum query problem is to preprocess a static m by n matrix (two dimensional array) A of size N=m⋅n, such that subsequent queries, asking for the position of the minimum element in a rectangular range within A, can be answered efficiently. We study the trade-off between the space and query time of the problem. We show that every algorithm enabled to access A during the query and using a data structure of size O(N/c) bits requires Ω(c) query time, for any c where 1≤c≤N. This lower bound holds for arrays of any dimension. In particular, for the one dimensional version of the problem, the lower bound is tight up to a constant factor. In two dimensions, we complement the lower bound with an indexing data structure of size O(N/c) bits which can be preprocessed in O(N) time to support O(clog 2 c) query time. For c=O(1), this is the first O(1) query time algorithm using a data structure of optimal size O(N) bits. For the case where queries can not probe A, we give a data structure of size O(N⋅min {m,log n}) bits with O(1) query time, assuming m≤n. This leaves a gap to the space lower bound of Ω(Nlog m) bits for this version of the problem.