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

.

## Filters

##
###
An O(log N) deterministic packet-routing scheme

1992
*
Journal of the ACM
*

A determuustlc

doi:10.1145/147508.147517
fatcat:pt37lwwnf5byvdxt5uc2ir6bli
*O*(*log**N*)-time algorithm for the problem of routing*an*arbitrary permutation on*an**N*-processor bounded-degree*network*with bounded buffers is presented. ... Unhke all previous deterministic solutions to this problem, our routing scheme does not reduce the routing problem to*sorting*and does not use the*sorting**network*of Ajtai, et al. [1]. ...*An**O*(*log**N*)-*sorting**network*gives*an**O*(*log**N*) solution for the acyclic, switching*network*, packet-routing problem. ...##
###
Secure merge with O(n log log n) secure operation
[article]

2020
*
IACR Cryptology ePrint Archive
*

Using blackbox access to

dblp:journals/iacr/FalkO20
fatcat:rksbxv7wjjdu7m3dtjqaw3ksse
*an**O*(*n*)-communication secure shuffle, we give the first secure merge algorithm that requires only*O*(*n**log**log**n*) communication. ... The best data-oblivious*sorting*algorithms for*sorting*a list of*n*elements require*O*(*n**log**n*) comparisons. ... The AKS*sorting**network*[AKS83] requires*O*(*n**log**n*) comparators to*sort**n*elements. ...##
###
An O(n log n)-Time Algorithm for the k-Center Problem in Trees

2018
*
International Symposium on Computational Geometry
*

Comput., 1983) gave

doi:10.4230/lipics.socg.2018.72
dblp:conf/compgeom/0001Z18
fatcat:ruwgocgwjzesdchks5uv4sx4nm
*an*algorithm that can solve the problem in*O*(*n**log*2*n*) time by using Cole's parametric search. ... In this paper, we present*an**O*(*n**log**n*) time algorithm for the problem and thus settle the open problem affirmatively. ...*sorting**network*[2] . ...##
###
Perfectly Secure Oblivious Parallel RAM with O(log 3 N/ log log N) Overhead
[article]

2020
*
IACR Cryptology ePrint Archive
*

Similarly, Oblivious Parallel RAM (OPRAM) compiles a parallel RAM program to

dblp:journals/iacr/ChanLNS20
fatcat:6a427rcl6bgofpgz5cy5mv5t7q
*an*oblivious counterpart. ... Oblivious RAM (ORAM) is a technique for compiling any RAM program to*an*oblivious counterpart, i.e., one whose access patterns do not leak information about the secret inputs. ...*O*(*n**log*2*n*) work, but to*sort*only 0/1 elements, i.e. tight compaction, a bitonic*sort*augmented with counting takes only*O*(*n**log**n*) work). ...##
###
An O(n^2 log^2 n) Time Algorithm for Minmax Regret Minsum Sink on Path Networks

2018
*
International Symposium on Algorithms and Computation
*

We want to minimize the aggregate evacuation time to

doi:10.4230/lipics.isaac.2018.14
dblp:conf/isaac/BhattacharyaHKK18
fatcat:p6y7fskgerdo3bxpils6zc53u4
*an*evacuation center (called a sink) on a path*network*with uniform edge capacities. ... We present the first sub-cubic time algorithm in*n*to solve this problem, where*n*is the number of vertices. ... [2] that*an*aggregate time k-sink in path*networks*can be found in*O*(kn*log*3*n*) (resp.*O*(kn 2*log*2*n*)) time, if edge capacities are uniform (resp. nonuniform). ...##
###
Optimal parallel selection has complexity O(Log Log N)

1989
*
Journal of computer and system sciences (Print)
*

We show that in the deterministic comparison model for parallel computation, p=

doi:10.1016/0022-0000(89)90035-4
fatcat:z7kk67veffhm7fttm2gxwuwwvq
*n*processors can select the kth smallest item from a set of*n*numbers in*O*(*log**log**n*) parallel time. ... This optimal time bound holds even if p =*o*(*n*). ... The*log**n*depth*sorting**network*of Ajtai, Komlbs, and Szemeredi [ 1 ] implies that*log**n*is both*an*upper and lower bound for*sorting*in this model becaue the PCT is more powerful than a*network*. ...##
###
Sorting Short Keys in Circuits of Size o(n log n)
[article]

2020
*
arXiv
*
pre-print

Therefore, if the keys to be

arXiv:2010.09884v2
fatcat:ji2762hgevbpxijglqczbp5sxu
*sorted*are short, say, k <*o*(*log**n*), our result is asymptotically better than the classical AKS*sorting**network*(ignoring*log*^* terms); and we also overcome the*n**log**n*barrier ... We also show that if the Li-Li*network*coding conjecture is true, our upper bound is optimal, barring*log*^* terms, for every k as long as k =*O*(*log**n*). ... Acknowledgments Elaine Shi would like to thank Bruce Maggs for explaining the AKS*sorting**network*[AKS83] , for numerous extremely helpful discussions regarding the elegant Arora, Leighton, Maggs self-routing ...##
###
Treemap: An O(log n) algorithm for indoor simultaneous localization and mapping

2006
*
Autonomous Robots
*

When the robot moves to a different subregion a full least-square estimate for that region is computed in only

doi:10.1007/s10514-006-9043-2
fatcat:pww3nmtyqzaafmca4rfyzsoq7u
*O*(k 3*log**n*) computation time for*n*landmarks. ... A global least square estimate needs*O*(kn) computation time with a very small constant (12.37ms for*n*= 11300). ... By definition 1.2 this holds for only*O*(1) leaves taking*O*(k*log**n*) time. ...##
###
MST construction in O(log log n) communication rounds

2003
*
Proceedings of the fifteenth annual ACM symposium on Parallel algorithms and architectures - SPAA '03
*

We consider a simple model for overlay

doi:10.1145/777412.777428
dblp:conf/spaa/LotkerPPP03
fatcat:j3krvcrcb5ca3glgpmwadwlk7q
*networks*, where all*n*processes are connected to all other processes, and each message contains at most*O*(*log**n*) bits. ... For this model, we present a distributed algorithm that constructs a minimumweight spanning tree in*O*(*log**log**n*) communication rounds, where in each round any process can send a message to each other process ... In this paper we present*an*MST construction algorithm that works in*O*(*log**log**n*) communication rounds, where in each round each process can send*O*(*log**n*) bits to each other process (more intuitively, ...##
###
MST construction in O(log log n) communication rounds

2003
*
Proceedings of the fifteenth annual ACM symposium on Parallel algorithms and architectures - SPAA '03
*

We consider a simple model for overlay

doi:10.1145/777426.777428
fatcat:4cdmg4apbzghxn7niolz5ovhxe
*networks*, where all*n*processes are connected to all other processes, and each message contains at most*O*(*log**n*) bits. ... For this model, we present a distributed algorithm that constructs a minimumweight spanning tree in*O*(*log**log**n*) communication rounds, where in each round any process can send a message to each other process ... In this paper we present*an*MST construction algorithm that works in*O*(*log**log**n*) communication rounds, where in each round each process can send*O*(*log**n*) bits to each other process (more intuitively, ...##
###
Neural Shuffle-Exchange Networks – Sequence Processing in O(n log n) Time
[article]

2019
*
arXiv
*
pre-print

We introduce a new Shuffle-Exchange neural

arXiv:1907.07897v3
fatcat:g644nxdyxjakhjw2t6jbnfumta
*network*model for sequence to sequence tasks which have*O*(*log**n*) depth and*O*(*n**log**n*) total complexity. ... To this end, a vast majority of the state-of-the-art models use attention mechanism which is of*O*(*n*^2) complexity that leads to slow execution for long sequences. ... Although the best known*sorting*circuits have depth*O*(*log**n*) (Ajtai et al., 1983; Seiferas, 2009) , they are huge, with estimated depth over 100*log**n*. ...##
###
Neural Shuffle-Exchange Networks - Sequence Processing in O(n log n) Time

2019
*
Neural Information Processing Systems
*

We introduce a new Shuffle-Exchange neural

dblp:conf/nips/FreivaldsOS19
fatcat:ogdbdlylvjem3n3z5tcjtkbaz4
*network*model for sequence to sequence tasks which have*O*(*log**n*) depth and*O*(*n**log**n*) total complexity. ... To this end, a vast majority of the state-of-the-art models use attention mechanism which is of*O*(*n*2 ) complexity that leads to slow execution for long sequences. ... Although the best known*sorting*circuits have depth*O*(*log**n*) (Ajtai et al., 1983; Seiferas, 2009) , they are huge, with estimated depth over 100*log**n*. ...##
###
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)
*

This amounts to

doi:10.1137/0210023
fatcat:ixaxf22jvfcern7e7nrdcjpthq
*an*effort of*O*( m*log**n*l m ) =*O*(*n*log2*n*) if one uses trimming and*an*inferior bound, of*O*(*n*FIG. 1 sup,.. mini,,,, d ( x , , y). ...*log**n**log*-=*O*( pn log2*n*). ( (lo:*n*) )*n*min { p log2*n*,*n**log*p } ) 8 . ...##
###
Selection networks with 8n log2 n size and O(log n) depth
[chapter]

1992
*
Lecture Notes in Computer Science
*

A

doi:10.1007/3-540-56279-6_69
fatcat:ftwtkip4jvcftp76vaa42mcrbq
*sorting**network*with $*n*$ inputs is also caUed*an**n*-sorter. ... Since*n*-sorters are also $(*n*,k)$-selectors, the existence of*n*-sorters with $*O*(*n*\*log**n*)$ size and $*O*(\*log**n*)$ depth, given in $[AKS83a] [AKS83b]$ , immediately implies the existence of $(*n*,k)$ -selectors ...##
###
Secure Merge in Linear Time and O(log log N) Rounds
[article]

2022
*
IACR Cryptology ePrint Archive
*

*n*) communication and

*O*(

*log*

*n*) round complexity. ... Our protocol improves on previous work of [FNO22], which gave a

*O*(

*n*) communication and

*O*(

*n*) round complexity protocol, and other "naive" approaches, such as the shuffle-

*sort*paradigm, which has

*O*(

*n*

*log*... Protocol Computation Communication Rounds (Garbled) Merging

*Network*[Folklore]

*O*(κ •

*n*

*log*

*n*)

*O*(κ •

*n*

*log*

*n*)

*O*(1) (GMW) Merging

*Network*[Folklore]

*O*(

*n*

*log*

*n*)

*O*(

*n*

*log*

*n*)

*O*(

*log*

*n*) (FHE) Merging

*Network*[ ...

« Previous

*Showing results 1 — 15 out of 123,286 results*