path copying

This work proposes FeAVL, a fully persistent dynamic string data structure that efficiently supports split, concatenate, single-character update, equality testing, and longest common extension (LCE) queries. By integrating AVL trees with path-copying persistence for the first time, FeAVL achieves worst-case O(log n) time per update operation and O(log n + log²ℓ) time for LCE queries, creating only O(log n) new nodes per update. The design is further enhanced with an AVL-grammar-based compression scheme, yielding a total space complexity of O(g₀ + I + U log nₘₐₓ) after U updates, where g₀ denotes the initial grammar size, I the number of insertions, and nₘₐₓ the maximum string length. This approach avoids pitfalls of amortized analysis while maintaining strong theoretical guarantees and practical compression performance.

This paper addresses the problem of efficiently maintaining tree decompositions for dynamic graphs under edge insertions and deletions, specifically for graphs with treewidth at most $k$, aiming to sustain a tree decomposition of width at most $9k+8$ and support dynamic programming queries over it. The method introduces the novel concept of *downward well-linked* tree decompositions and integrates a splay-tree-inspired local rotation mechanism with amortized analysis. This yields the first fully dynamic algorithm achieving $O_k(log n)$ amortized update time—breaking the previous best $O_k(n^{o(1)})$ bound established at FOCS’23. Moreover, the approach enables a practical realization of the dynamic Courcelle’s theorem: it reduces the dependence on $n$ from $n^{o(1)}$ to $log n$, while delivering a simpler structural design and a more unified analytical framework.

This paper addresses the high node metadata overhead and weak support for parallelism and external memory in long-string indexing. We propose zip-tries—a lightweight, dynamic, and memory-efficient string index structure. Our contributions are threefold: (1) the first node-level metadata compression achieving $O(loglog n + loglog(k/alpha))$ bits per node—an exponential reduction; (2) a general parallel string comparison framework enabling $O(log n)$ span for search and update operations under the PRAM model; and (3) an extension to the PEM model, yielding a parallel string B-tree variant with $O(log_B n)$ I/O span and efficient parallel prefix queries. Theoretical analysis spans RAM, word RAM, PRAM, and PEM models, ensuring optimal time complexity $O(k + log n)$ while maintaining strong engineering practicality.

Existing balanced tree structures—such as AVL trees—lack tight information-theoretic lower bounds on encoding size, suffer from intractable exact enumeration, and offer limited support for efficient static queries. Method: We introduce a novel tree decomposition framework grounded in generating functions and combinatorial enumeration, enabling rigorous asymptotic analysis; we further design a succinct data structure supporting constant-time queries—including ancestor, subtree size, and level-order traversal—and generalize our approach to recursively defined balanced tree families (e.g., red-black trees, WB-trees) via functional equations. Contribution/Results: We establish the first provable information-theoretic lower bound for AVL tree encoding—approximately 0.938 bits per node—and present a succinct representation achieving this bound while supporting rich navigational queries. Our unified framework extends to broader classes of height-balanced trees, bridging theoretical limits and practical succinct data structure design.

In highly dynamic P2P networks where nodes churn at rate $O(n/log n)$ per round, maintaining distributed data structures is notoriously challenging. Method: This paper presents the first fully distributed, theoretically sound skip list construction and maintenance algorithm, based on a randomized protocol leveraging only local information; it supports $O(log n)$-round parallel merging and batch deletion, and achieves robustness against oblivious adversaries. Contributions/Results: (1) The first distributed skip list provably maintaining structural correctness with high probability under $poly(n)$ rounds of high churn; (2) Message complexity of $polylog(n)$ messages per node per round, each of $polylog(n)$ bits; (3) Overhead scales linearly with churn rate, ensuring scalability, locality, and generality—establishing a new paradigm for maintaining dynamic graph structures and other distributed abstractions.

This work addresses the performance degradation of dynamic k-d trees under frequent updates due to structural imbalance. The authors systematically propose and implement a novel maintenance strategy based on power-of-two structures: the dynamic tree is organized as a collection of static k-d trees, each of size equal to an integer power of two, accompanied by tailored insertion and deletion algorithms. The study further presents a comparative evaluation against local subtree reconstruction-based rebalancing techniques. Through extensive experiments, the paper quantitatively reveals—for the first time—the performance trade-offs between these two approaches under varying operational workloads, offering empirical guidance for selecting appropriate indexing structures in high-dimensional dynamic settings.

This work investigates the complexity of incremental view maintenance (IVM) under insert-only updates in databases defined over commutative semirings without additive inverses. By introducing the class of p-hierarchical conjunctive queries and integrating semiring algebraic structure with the fractional hypertree width (fhtw) measure, it establishes the first intrinsic connection between semiring properties and IVM complexity. For self-join-free conjunctive queries, the paper provides a dichotomy criterion for constant-time maintainability: any p-hierarchical query admits amortized O(N^{fhtw−1}) update time and constant delay enumeration; in particular, α-acyclic p-hierarchical queries achieve constant amortized update time. Conversely, it proves that non-p-hierarchical queries cannot simultaneously support constant update time and constant enumeration delay.

This work proposes UFO Trees, a novel parallel batch-dynamic tree data structure designed to efficiently support edge updates and a broad range of queries—including connectivity and path operations—on dynamic trees. UFO Trees are the first to simultaneously achieve low space overhead, extensive query functionality, and high-performance parallel batch updates, while matching the serial performance of classical Link-Cut Trees. Theoretical analysis demonstrates sublogarithmic time complexity on trees with low diameter. Experimental evaluation shows that UFO Trees significantly outperform ten existing implementations, including Link-Cut Trees, across both synthetic and real-world datasets, scaling efficiently to inputs of billions of elements.

This paper addresses the space–time optimality of dynamic ordered dictionaries: maintaining $n$ elements from a universe of size $U = mathrm{poly}(n)$, supporting insertions, deletions, rank, and select operations. We introduce the first construction to break the “tree-structure bottleneck”—the compressed lookup-table weighted Treap—which achieves $o(n)$-bit redundancy (specifically $O(log U)$, or $O(1)$ when $n$ and $U$ are known) in the dynamic setting, attaining near-entropy-optimal space $log inom{U}{n} + o(n)$. Time complexity is optimal amortized $Oig(1 + log n / log log Uig)$. Our result positively resolves an open problem posed by Pibiri and Venturini, establishing a new theoretical benchmark for dynamic order-statistic data structures.

This work addresses the problem of range minimum queries on leaf-to-ancestor paths in trees within the deterministic comparison model, where edge or node weights are accessible only through a comparison oracle. The authors propose a static data structure that achieves worst-case O(1) query time without any oracle calls during queries. This is accomplished by transforming edge weights to node weights, applying deterministic tie-breaking, employing ladder decomposition, binary lifting, and a sparse-table RMQ technique indexed via oracle-based selection. The structure requires O(n log h) preprocessing time, space, and oracle invocations, where n is the number of nodes and h the tree height. Notably, this is the first solution in the deterministic comparison model to achieve constant-time leaf-to-ancestor path minimum queries with zero oracle calls at query time, and its preprocessing oracle complexity matches the theoretical lower bound, establishing optimality.