Retroactive Monotonic Priority Queues via Range Searching

TL;DR

This work investigates fully retroactive monotonic priority queues (FR-MonoPQ) and shows that minimum extraction can be reduced to a range-searching problem via a geometric representation of elements. It presents two FR-MonoPQ constructions: a general design with per-operation time $O(\log m + T(m))$, where $T(m)=\max\{Q(m),U(m)\}$, and a refined design achieving $O(\log m \log \log m)$ per operation. The key technique is a reduction to 2D range searching using points $(\operatorname{insertionTime}(e), e)$ and a rectangle $R(t)=(-\infty,t]\times(\operatorname{lastExtracted}(t),\infty)$, enabling GetMin$(t)$ queries via min-y range searching; the latter is implemented using a dynamic 2D range tree (Mehlhorn–Näher). The results advance the understanding of fully retroactive data structures by providing concrete, near-optimal bounds for a monotonic subset and motivating further study of broader retroactive priority queue variants.

Abstract

The best-known fully retroactive priority queue costs $O(\log^2 m \log \log m)$ time per operation, where $m$ is the number of operations performed on the data structure. In contrast, standard (non-retroactive) and partially retroactive priority queues can cost $O(\log m)$ time per operation. So far, it is unknown whether this $O(\log m)$ bound can be achieved for fully retroactive priority queues. In this work, we study a restricted variant of priority queues known as monotonic priority queues. First, we show that finding the minimum in a retroactive monotonic priority queue is a special case of the range-searching problem. Then, we design a fully retroactive monotonic priority queue with a cost of $O(\log m + T(m))$ time per operation, where $T(m)$ is the maximum between the query and the update time of a specific range-searching data structure with $m$ elements. Finally, we design a fully retroactive monotonic priority queue that costs $O(\log m \log \log m)$ time per operation.

Figures (4)

• Figure 1: Geometric view of retroactive priority queues. Blue segments represent elements, red segments represent $\operatorname{extract-min}()$ operations, and green dotted segments represent $GetMin(t)$ queries.
• Figure 2: Example of the chain of reaction in retroactive priority queues. Lines in green represent the that occur because of the operation. Dotted lines represent the state of the segment before the operation. Filled lines represent the state of the segment after the operation.
• Figure 3: Illustration of monotonic retroactive priority queues. The gray rectangles represent areas where elements cannot be inserted in, because of the monotonic restriction.
• Figure 4: Illustration of \ref{['lem:reduction']}. The point that intersects the rectangle is $\operatorname{lastExtracted}(t)$. All points inside the shaded area (the rectangle) exist at time $t$, except $\operatorname{lastExtracted}(t)$. The marked point is the point with minimum value among all the points that exist at time $t$.

Theorems & Definitions (14)

• Definition 1
• Definition 2
• Definition 3
• Definition 4
• Remark
• Lemma 14: Conditions for Existence
• Corollary 15: GetMin Expression
• Lemma 16
• Lemma 17
• Remark