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

.

## Filters

##
###
Storing a Sparse Table with 0(1) Worst Case Access Time

1984
*
Journal of the ACM
*

*A*data structure for representing

*a*set of n items from

*a*umverse of m items, which uses space n + o(n) and accommodates membership queries m constant

*time*is described. ... This sequence of probes can be adaptive: The

*Storing*

*a*

*Sparse*

*Table*

*with*

*0*(

*1*)

*Worst*

*Case*

*Access*

*Time*539 next cell to be probed is determined precisely by q and the contents of the cells previously probed ...

*A*second

*table*

*A*[j], ,j E I, is used to

*store*offsets:

*A*[j] =

*0*if Wj = ~, otherwise B[

*a*] +

*A*[j] is the address in T' associated

*with*~ forj E ~. ...

##
###
High-speed Firewall Rule Verification with O(1) Worst-case Access Time

2017
*
International Journal of Network Security
*

In this paper, we have presented several techniques to improve the speed of firewall rule verification

dblp:journals/ijnsec/KhummaneeT17
fatcat:jumhbxubfjgczifbbyidve6oj4
*with*O(*1*) worstcase*access**time*. ... Firewalls enforced by rules are*a*security measure for verifying huge packets at gateway networks. Therefore, they probably act as bottlenecks of the networks. ... However, provided that the operation has known the in-dex of i and j to*access*an element in the matrix, the*worst*-*case**access**time*will be O(*1*).*Sparse*matrix storage formats. ...##
###
Space Efficient Hash Tables with Worst Case Constant Access Time
[chapter]

2003
*
Lecture Notes in Computer Science
*

This is the first dictionary that has

doi:10.1007/3-540-36494-3_25
fatcat:55hp4pjbvbh7xiqpkatvdvefvy
*worst**case*constant*access**time*and expected constant update*time*, works*with*(*1*+ ε) n space, and supports satellite information. ... We generalize Cuckoo Hashing [23] to d-ary Cuckoo Hashing and show how this yields*a*simple hash*table*data structure that*stores*n elements in (*1*+ ε) n memory cells, for any constant ε >*0*. ... The main contribution of this paper is*a*hash*table*data structure*with**worst**case*constant*access**time*and memory consumption only (*1*+ε) n. ...##
###
Space Efficient Hash Tables with Worst Case Constant Access Time

2004
*
Theory of Computing Systems
*

This is the first dictionary that has

doi:10.1007/s00224-004-1195-x
fatcat:jjt7kabgefdptn567emefekn2m
*worst**case*constant*access**time*and expected constant update*time*, works*with*(*1*+ ε) n space, and supports satellite information. ... We generalize Cuckoo Hashing [23] to d-ary Cuckoo Hashing and show how this yields*a*simple hash*table*data structure that*stores*n elements in (*1*+ ε) n memory cells, for any constant ε >*0*. ... The main contribution of this paper is*a*hash*table*data structure*with**worst**case*constant*access**time*and memory consumption only (*1*+ε) n. ...##
###
Low Redundancy in Static Dictionaries with O(1) Worst Case Lookup Time
[chapter]

1999
*
Lecture Notes in Computer Science
*

We study this problem in

doi:10.1007/3-540-48523-6_56
fatcat:hzh6za2hqjfh7oaohpbijerxny
*a*unit cost RAM model*with*word size Ω(log |U |), and show that for n-element subsets, constant*worst**case*query*time*can be obtained using B + O(log log |U |) + o(n) bits of storage ... For |U | = n log O(*1*) n the dictionary supports constant*time*rank queries. ... For m = n log O(*1*) n,*a*static rank dictionary*with**worst**case*constant query*time*can be represented using B + O( n log 2 log n log n ) bits. ...##
###
Low Redundancy in Dictionaries with O(1) Worst Case Lookup Time

1998
*
BRICS Report Series
*

We study this problem in

doi:10.7146/brics.v5i28.19434
fatcat:dy3khwebfjg3hmbwopqebg5gc4
*a*unit cost RAM model*with*word size Omega(log |U|), and show that for n-element subsets,<br />constant*worst**case*query*time*can be obtained using B +O(log log |U|)+o(n) bits ...*A*static dictionary is*a*data structure for*storing*subsets of*a*finite universe U, so that membership queries can be answered efficiently. ... Setting b = c = α log m, for some*0*< α <*1*we get the following: Theorem 2*A*static rank dictionary*with**worst**case*constant query*time*, can be represented using B + O( m log log m log m ) bits. ...##
###
Revisiting Sparse Dynamic Programming for the 0/1 Knapsack Problem

2020
*
49th International Conference on Parallel Processing - ICPP
*

REVISITING

doi:10.1145/3404397.3404462
dblp:conf/icpp/SifatPR20
fatcat:qlgzble6jnfsddr3yanf4c4i6y
*SPARSE*DYNAMIC PROGRAMMING FOR THE*0*/*1*KNAPSACK PROBLEM The*0*/*1*-Knapsack Problem is*a*classic NP-hard problem. ...*A*socalled, "*sparse*" DP algorithm (SKPDP) that performs fewer operations than the standard algorithm (KPDP) is well known. ... In the*worst**case*,*a*problem instance will hardly have any sparsity and, therefore, most of the rows in the*sparse**table*will be of length C. ...##
###
A Simplified Description of Child Tables for Sequence Similarity Search

2018
*
IEEE/ACM Transactions on Computational Biology & Bioinformatics
*

In any

doi:10.1109/tcbb.2018.2796064
pmid:29994365
fatcat:gvpmuoic7vetrcdonghl5f3qpu
*case*, we then seek sequence segment-pairs*with*high model-likelihood of being related. ... This paper aims to provide*a*more*accessible*description of child*tables*, and demonstrate their generality: they apply equally to all the above-mentioned seed types and more. ... The original child*table*breaks ties by choosing the first minimum [15] , which leads to*worst*-*case*search*time*proportional to the alphabet size. ...##
###
A Dynamic Space-Efficient Filter with Constant Time Operations

2020
*
Scandinavian Workshop on Algorithm Theory
*

For the

doi:10.4230/lipics.swat.2020.11
dblp:conf/swat/BerceaE20
fatcat:xd4z4ultsva4periughzglub2u
*case*that log(*1*/ε) = O(log log n), we present the first space-efficient dynamic filter*with*constant*time*operations in the*worst**case*(whp). ... The goal is to obtain dynamic filters that are space-efficient (the space is*1*+o(*1*)*times*the information-theoretic lower bound) and support all operations in constant*time**with*high probability. ... The proof of Thm.*1*deals*with*the*sparse**case*and dense*case*separately. The theorem for the*sparse**case*, in which log(*1*/ε) = ω(log log n), is proven in Sec. 6 . ...##
###
Faster range minimum queries
[article]

2017
*
arXiv
*
pre-print

We subsequently refine our technique, combining it

arXiv:1711.10385v1
fatcat:civqumrk3fb3xo2lwjfz4rmxye
*with*one of the existing succinct solutions*with*O(*1*)*worst*-*case**time*queries and no*access*to the input array. ... In this work, we present*a*simple data structure,*with*very fast construction, which allows to handle queries in constant*time*on average. ... As*a*next solution we thus proposed to combine our technique*with*one of the existing succinct solutions*with*O(*1*)*worst*-*case**time*queries and no*access*to the input array. ...##
###
Fast address lookups using controlled prefix expansion

1999
*
ACM Transactions on Computer Systems
*

On

doi:10.1145/296502.296503
fatcat:zpxuj3ftivhdvi2ccmk6hpbauq
*a*300MHz Pentium II which takes 4 cycles for*accessing*the first word of the L2 cacheline, this algorithm has*a**worst*-*case*search*time*of 180 nsec.,*a**worst*-*case*insert/delete*time*of 2.5 msec., and ... When applied to Binary Search on Levels, our techniques improve*worst*-*case*search*times*by nearly*a*factor of 2 (using twice as much storage) for the MaeEast database. ... Assume each node has*a**0*-pointer and*a**0*-info field, and similarly*a**1*-pointer and*1*-info field. ...##
###
Static analysis of the worst-case memory performance for irregular codes with indirections

2012
*
ACM Transactions on Architecture and Code Optimization (TACO)
*

Real-

doi:10.1145/2355585.2355593
fatcat:q7dojf3qgjgbhisnmpk4pnhjzy
*time*systems are subject to*timing*constraints, whose upper bound is given by the*Worst*-*Case*Execution*Time*(WCET). ... The*worst*-*case*memory performance (WCMP) component of the WCET can only be estimated*with*the precise knowledge of the stream of data addresses*accessed*by the code, which is determined by the*access*patterns ... Figure 3 ,*case*(*a*), shows the*sparse*matrix that produces this kind of*worst*-*case**access*pattern in the*accesses*to vector x. ...##
###
DACs: Bringing direct access to variable-length codes

2013
*
Information Processing & Management
*

We show some experiments demonstrating that the technique is not only simple, but also competitive in

doi:10.1016/j.ipm.2012.08.003
fatcat:nshc4t7qsvf7laqyihd4y5qgia
*time*and space*with*existing solutions in several applications, such as the representation of LCP arrays ... We present*a*new variable-length encoding scheme for sequences of integers, Directly Addressable Codes (DACs), which enables direct*access*to any element of the encoded sequence without the need of any ... Acknowledgments This work was founded in part by MCIN grant TIN2009-14560-C03-02 and CDTI CEN-20091048, and Xunta de Galicia grant 2010/17 (for the first and second authors), and Fondecyt grant*1*-110066 ...##
###
Solving structured nonsmooth convex optimization with complexity $$\mathcal {O}(\varepsilon ^{-1/2})$$ O ( ε - 1 / 2 )

2017
*
TOP - An Official Journal of the Spanish Society of Statistics and Operations Research
*

If the nonsmoothness of the problem is manifested in

doi:10.1007/s11750-017-0462-3
fatcat:y7lzfuoqhfg55abt3pybnu6icu
*a*structured way, we reformulate the problem so that it can be solved efficiently by*a*new setup of OSGA (called OSGA-V)*with*the complexity O(ε −*1*/ ... ) for Lipschitz continuous nonsmooth problems and O(ε −*1*/2 ) for smooth problems*with*Lipschitz continuous gradient. ... We are very thankful to anonymous referees for*a*careful reading and many useful suggestions, which improved the paper. ...##
###
A sparse table implementation of priority queues
[chapter]

1981
*
Lecture Notes in Computer Science
*

To improve the

doi:10.1007/3-540-10843-2_34
fatcat:24idhcybq5badj56uvqnbx4kfy
*worst**case*behavior,*a*more complicated*sparse**table*scheme is introduced in Section 5 which requires no more than O(n log 2n)*time*to build up*a**table**with*n elements. ... To improve the*worst**case*performance an additional structure is imposed on the*sparse**table*, yielding*a*more complicated scheme which we refer to as the hierarchical*sparse**table*. ...
« Previous

*Showing results 1 — 15 out of 26,782 results*