Indexing Range Maximum-Sum Segment Queries with Offsets

2026-07-21

AI Summary

This study addresses the problem of range maximum-sum segment queries with a global offset. The authors propose the first unified indexing structure for this problem, integrating hierarchical design, divide-and-conquer strategy, and run-length encoding compression to achieve flexible space–time trade-offs. Specifically, their approach yields an O(n log n)-space index with O(log²n) query time on general arrays; more generally, for any parameter d, it achieves O(dn) space and O(dn^{1/d} log n) query time. Notably, on binary arrays, they establish a tight Θ(n^{2/3}) bound on the number of incompatible offsets, revealing the intrinsic complexity of the problem.

Abstract

Given an array of $n$ real numbers, the maximum segment sum (MSS) problem is to find a contiguous subarray that has the largest sum. While the MSS problem can be solved optimally with Kadane's algorithm in $O(n)$ time, the study of its indexing version spawned new extensions such as (a) retrieving the MSS after subtracting a query offset parameter for all array entries or (b) retrieving the MSS for arbitrary query ranges. We here study the combination of both problems (a) and (b), which requires retrieving the MSS for arbitrary query ranges after subtracting a query offset parameter for all array entries. For that, we present an index whose query time is only slower than the best known for (a) by a factor of $O(\log n)$. In detail, our index uses $O(n \log n)$ space, supports queries in $O(\log^2 n)$ time, and can be constructed in $O(n \log^3 n)$ time. More generally, for every integer $d$ with $1\le d\le\lceil\log_2 n\rceil$, we give an $O(dn)$-space index with $O(dn^{1/d}\log n)$ query time; in particular, for every fixed $\varepsilon>0$, we obtain linear space and $O(n^\varepsilon\log n)$ query time. As side results, we obtain the same time-space trade-off in terms of the number of runs of a run-length encoded input, deduce a solution for (a) that works in run-length compressed space and time, and prove a tight $Θ(n^{2/3})$ bound on the number of non-compatible offsets for binary arrays. Finally, we give supportive lower bounds for our query problem, showing that there is only a polylogarithmic gap of improvement left.

Problem

• Range Maximum-Sum Segment
• Query Offset
• Indexing
• Maximum Subarray Problem
• Data Structures

Innovation

• range maximum-sum segment
• query offset
• indexing data structure
• time-space trade-off
• run-length encoding