A copy of this work was available on the public web and has been preserved in the Wayback Machine. The capture dates from 2007; you can also visit the original URL.
The file type is `application/pdf`

.

## Filters

##
###
An $O(n\log \log n)$-Time Algorithm for Triangulating a Simple Polygon

1988
*
SIAM journal on computing (Print)
*

We propose

doi:10.1137/0217010
fatcat:h7x4xw7xuzbx3mdhz776gcj3ce
*an**O*(*n**log*logn)-*time*algorithm for this problem, improving on the previously best bound of*O*(*n**log**n*) and showing that triangulation is not as hard as sorting. ... Given a simple*n*-vertex polygon, the triangulation problem is to partition the interior of the polygon into*n*-2 triangles by adding*n*-3 nonintersecting diagonals. ... We thank Brenda Baker for her many helpful comments on*an*earlier draft of this paper, and Bernard Chazelle for his thorough reading of this version of the paper. ...##
###
An In-Place Sorting with O(n log n) Comparisons and O(n) Moves
[article]

2003
*
arXiv
*
pre-print

We present the first in-place algorithm for sorting

arXiv:cs/0305005v1
fatcat:zc5qqdgpyre4bohnzxjlb4xqqi
*an*array of size*n*that performs, in the*worst**case*, at most*O*(*n**log**n*) element comparisons and*O*(*n*) element transports. ... Raman, Sorting*with*minimum data movement, J. ... The corresponding heap*tree*is thus of constant height, which results in*an*algorithm sorting*with**O*(*n*) moves,*O*(1) storage, and*O*(*n*1+ε ) comparisons. ...##
###
Building a Balanced k-d Tree in O(kn log n) Time
[article]

2022
*
arXiv
*
pre-print

The original description of the k-d

arXiv:1410.5420v33
fatcat:ymoqzbr2mvcq3podmfeapft5kq
*tree*recognized that rebalancing techniques, such as are used to build*an*AVL*tree*or a red-black*tree*, are not applicable to a k-d*tree*. ... This paper discusses*an*alternative algorithm that builds a balanced k-d*tree*by presorting the data in each of k dimensions prior to building the*tree*. ... Quicksort [14] finds the median in*O*(*n*)*time*in the best*case*, but in*O**n*2*time*in the*worst**case*[23] . ...##
###
QuickXsort: Efficient Sorting with n log n - 1.399n +o(n) Comparisons on Average
[article]

2013
*
arXiv
*
pre-print

A

arXiv:1307.3033v1
fatcat:ksej3rtoxzcmropysxdhuqagzy
*worst**case*of*n**log**n*+*O*(*n*) comparisons can be achieved without significantly affecting the average*case*. Furthermore, we describe*an*implementation of MergeInsertion for small*n*. ... Taking MergeInsertion as a base*case*for QuickMergesort, we establish a*worst*-*case*efficient sorting algorithm calling for*n**log**n*- 1.3999n +*o*(*n*) comparisons on average. ... Table 1 : 1 Constant-factor-*optimal*sorting*with**n**log**n*+ κ*n*+*o*(*n*) comparisons. Mem. Other κ*Worst*κ Avg. κ Exper. ...##
###
An $O(n\log ^2 n)$ Algorithm for the kth Longest Path in a Tree with Applications to Location Problems

1981
*
SIAM journal on computing (Print)
*

It is desirable in these

doi:10.1137/0210023
fatcat:ixaxf22jvfcern7e7nrdcjpthq
*cases*to have selection algorithms that run in sublinear*time*in terms of the cardinality of the set. This paper presents a successful development in this direction. ... The methods developed here are applied to improve the previously known upper bounds for the*time*complexity of various location problems. ... Thus, the*searching*stage takes*O*((*n*+*n**log**n*)*log*IRl)*time*, and hence the location problem is solved in*O*(*n**log*''*n*)*time*. B . A /*N*/ p . ...##
###
Fully Dynamic Connectivity in O(log n(loglog n)^2) Amortized Expected Time
[article]

2022
*
arXiv
*
pre-print

We present a randomized Las Vegas dynamic connectivity data structure

arXiv:1609.05867v2
fatcat:avm5glsex5hlbgzoigxhvrip5a
*with**O*(*log**n*(loglog*n*)^2) amortized expected update*time*and*O*(*log**n*/logloglog*n*)*worst**case*query*time*, which comes very close to ... in*worst**case**O*(*log**n*/*log**log**log**n*)*time*. ... A buffer*tree*is implemented by*an*off-the-shelf mergeable*binary**tree**with**O*(*log**log**n*)*worst**case**time*for each attach, detach, and merge operation. 9 However, in order to support updates to the vector ...##
###
Efficient Range ORAM with 핆(log 2 N) Locality
[article]

2018
*
IACR Cryptology ePrint Archive
*

*log*

*N*). ... Oblivious RAM protocols (ORAMs) allow a client to

*access*data from

*an*untrusted storage device without revealing to that device any information about their

*access*pattern. ... rORAM answers affirmatively and provides a highly efficient range query mechanism

*with*locality,

*with*

*O*(

*log*2

*N*) seek and

*O*(r •

*log*2

*N*) non-amortized communication complexity,

*O*(

*log*

*N*)

*times*more efficient ...

##
###
A Simple Forward Algorithm to Solve General Dynamic Lot Sizing Models with n Periods in 0(n log n) or 0(n) Time

1991
*
Management science
*

One can therefore argue that our procedure is in practice of linear

doi:10.1287/mnsc.37.8.909
fatcat:5mjvm7uwwnekdlisdciqhqa6ly
*time*even in those rare settings where the*worst**case*bound is 0(*n**log**n*). ... The*n**log**n*complexity term in the most general procedure is obtained from the effort to insert or delete*an*element in this list which in the*worst**case*may be of size*n*, but in practice is very small ... The*access**time*in a balanced*binary**tree*is 0 (*log**n*). We can also rebalance such a*tree*after*an*insertion or deletion in 0(1og*n*)*time*, see Lemma 4.1 in Tarjan ( 1983). ...##
###
An in-place sorting with O(nlog n) comparisons and O(n) moves

2005
*
Journal of the ACM
*

We present the first in-place algorithm for sorting

doi:10.1145/1082036.1082037
fatcat:n36ky7vl6jfsdacyh3zc6dmcma
*an*array of size*n*that performs, in the*worst**case*, at most*O*(*n**log**n*) element comparisons and*O*(*n*) element transports. ... The heapsort [Floyd 1964; Williams 1964] was the first in-place sorting algorithm*with*a total running*time*bounded by*O*(*n*·*log**n*) in the*worst**case*. ... This leaves us*with*a fascinating question: Does there exist*an*algorithm operating in-place and performing, in the*worst**case*, at most*O*(*n*·*log**n*) comparisons,*O*(*n*) moves,*O*(*n*·*log**n*) arithmetic operations ...##
###
The Snapshot Index: An I/O-Optimal access method for timeslice queries

1995
*
Information Systems
*

We present

doi:10.1016/0306-4379(95)00011-r
fatcat:j5rns3b7yrfcvivncffwizmzka
*an**access*method for timeslice queries that reconstructs a past state s(t) of a*time*-evolving collection of objects, in*O*(*log*"*n*+ Is(t)l/b) I/*O*'8, where Is(t)1 denotes the size of the collection ... This is the first I I*O*-*optimal**access*method for this problem using*O*(*n*/b) space and*O*(1) updating (in the expected amortized sense due to the use of hashing.) ... Sellis for kindly providing us*with**access*to the computing facilities of his laboratory at the National TechnicaI University of Athens, where some of the simulations were performed while the second author ...##
###
Incremental discovery of the irredundant motif bases for all suffixes of a string in O(n2logn) time

2008
*
Theoretical Computer Science
*

Given a sequence s of

doi:10.1016/j.tcs.2008.08.002
fatcat:wjvrtw4pbrel7epltf3an5xxoi
*n*characters drawn from*an*alphabet Σ, the problem of extracting such a base from s had been previously solved in*time**O*(*n*2*log**n**log*| Σ |) and*O*(| Σ |*n*2*log*2*n**log**log**n*), respectively ... This problem was solved in a previous work in*time**O*(*n*3 ). A much faster incremental algorithm is described here, which takes*time**O*(*n*2*log**n*) for*binary*strings. ... This problem was solved in previous work in*time**O*(*n*3 ) [3] . A faster incremental algorithm is described here, which takes*time**O*(*n*2*log**n*) on a*binary*string. ...##
###
An I/O-efficient Distance Oracle for Evolving Real-World Graphs
[chapter]

2014
*
2015 Proceedings of the Seventeenth Workshop on Algorithm Engineering and Experiments (ALENEX)
*

Furthermore, in a batch setting, one would like to answer

doi:10.1137/1.9781611973754.14
dblp:conf/alenex/AjwaniMV15
fatcat:ydy7dz3jjjer3lqujwgui27bqy
*O*(*n*) such distance queries inÕ(*n*/B) I/Os. ... iii) answers batched shortest path queries using HDDs*with**an*average*time*per query of a few microseconds, (iv) results in a highly accurate shortest path estimate and (v) uses space linear in the number ... Complete*Binary**Tree*We first observe that for complete*binary**trees*, merely keeping the inorder number (*O*(*log**n*) bits)*with*each node allows us to answer distance queries*with**O*(1) instructions. ...##
###
Should Static Search Trees Ever Be Unbalanced?
[chapter]

2010
*
Lecture Notes in Computer Science
*

This suggests that for most applications, a balanced

doi:10.1007/978-3-642-17517-6_12
fatcat:y66tuj7qyfa2zi62adyx76qkey
*tree*is always a better option than*an*unbalanced one since the balanced*tree*has similar average*access**time*and much better*worst**case**access**time*... At the same*time*it is possible to guarantee that the average*access**time*P (R) in*tree*R is no more than the average*access**time*P (T ) in*tree*T plus*O*(*log*k P (T )). ... Related work*Optimal**search**trees*Knuth [12] showed that*an**optimal**binary**search**tree*can be built in*O*(*n*2 )*time*using*O*(*n*2 ) space. ...##
###
Should Static Search Trees Ever Be Unbalanced?
[article]

2010
*
arXiv
*
pre-print

This suggests that for most applications, a balanced

arXiv:1006.3715v1
fatcat:aqejvypclvfyfpsauo54roc33u
*tree*is always a better option than*an*unbalanced one since the balanced*tree*has similar average*access**time*and much better*worst**case**access**time*... We present several methods to restructure*an*unbalanced k-ary*search**tree*T into a new*tree*R that preserves many of the properties of T while having a height of _k*n*+1 which is one unit off of the*optimal*... Related work*Optimal**search**trees*Knuth [12] showed that*an**optimal**binary**search**tree*can be built in*O*(*n*2 )*time*using*O*(*n*2 ) space. ...##
###
An O(log2N) Fully-Balanced Resampling Algorithm for Particle Filters on Distributed Memory Architectures

2021
*
Algorithms
*

In this paper, we propose a novel parallel redistribution for DM that achieves

doi:10.3390/a14120342
fatcat:tu5ytxcuzbc3lacy4qh5do376q
*an**O*(log2N)*time*complexity. ... As the models become more complex and accurate, the run-*time*of PF applications becomes increasingly slow. Parallel computing can help to address this. ... data-dependent run-*time*and*an**O*(*N*)*time*complexity in the*worst*-*case*. ...
« Previous

*Showing results 1 — 15 out of 10,618 results*