7 research outputs found
Dynamic Kernels for Hitting Sets and Set Packing
Computing small kernels for the hitting set problem is a well-studied computational problem where we are given a hypergraph with n vertices and m hyperedges, each of size d for some small constant d, and a parameter k. The task is to compute a new hypergraph, called a kernel, whose size is polynomial with respect to the parameter k and which has a size-k hitting set if, and only if, the original hypergraph has one. State-of-the-art algorithms compute kernels of size k^d (which is a polynomial kernel size as d is a constant), and they do so in time m? 2^d poly(d) for a small polynomial poly(d) (which is a linear runtime as d is again a constant).
We generalize this task to the dynamic setting where hyperedges may continuously be added or deleted and one constantly has to keep track of a size-k^d hitting set kernel in memory (including moments when no size-k hitting set exists). This paper presents a deterministic solution with worst-case time 3^d poly(d) for updating the kernel upon hyperedge inserts and time 5^d poly(d) for updates upon deletions. These bounds nearly match the time 2^d poly(d) needed by the best static algorithm per hyperedge. Let us stress that for constant d our algorithm maintains a dynamic hitting set kernel with constant, deterministic, worst-case update time that is independent of n, m, and the parameter k. As a consequence, we also get a deterministic dynamic algorithm for keeping track of size-k hitting sets in d-hypergraphs with update times O(1) and query times O(c^k) where c = d - 1 + O(1/d) equals the best base known for the static setting
Determining 4-Edge-Connected Components in Linear Time
In this work, we present the first linear time deterministic algorithm computing the 4-edge-connected components of an undirected graph. First, we show an algorithm listing all 3-edge-cuts in a given 3-edge-connected graph, and then we use the output of this algorithm in order to determine the 4-edge-connected components of the graph
Prefix Filter: Practically and Theoretically Better Than Bloom
Many applications of approximate membership query data structures, or
filters, require only an incremental filter that supports insertions but not
deletions. However, the design space of incremental filters is missing a "sweet
spot" filter that combines space efficiency, fast queries, and fast insertions.
Incremental filters, such as the Bloom and blocked Bloom filter, are not space
efficient. Dynamic filters (i.e., supporting deletions), such as the cuckoo or
vector quotient filter, are space efficient but do not exhibit consistently
fast insertions and queries.
In this paper, we propose the prefix filter, an incremental filter that
addresses the above challenge: (1) its space (in bits) is similar to
state-of-the-art dynamic filters; (2) query throughput is high and is
comparable to that of the cuckoo filter; and (3) insert throughput is high with
overall build times faster than those of the vector quotient filter and cuckoo
filter by - and -, respectively.
We present a rigorous analysis of the prefix filter that holds also for
practical set sizes (i.e., ). The analysis deals with the probability
of failure, false positive rate, and probability that an operation requires
accessing more than a single cache line
LIPIcs, Volume 274, ESA 2023, Complete Volume
LIPIcs, Volume 274, ESA 2023, Complete Volum
LIPIcs, Volume 261, ICALP 2023, Complete Volume
LIPIcs, Volume 261, ICALP 2023, Complete Volum