1-Bounded Space Algorithms

• 1-Bounded space algorithms are computational methods that limit memory use to a constant number of bits or storage units, ensuring efficient execution under tight space constraints.
• They employ techniques such as lazy updates, recomputation, and compressed encodings to maintain strong time and approximation guarantees across diverse settings.
• The topic spans models from parallel search and dynamic programming to bin packing and read-only computations, highlighting both methodological variations and common low-space goals.

1-bounded space algorithms are algorithms designed under a stringent restriction on mutable state, but the phrase does not denote a single uniform model across the literature. In parallel combinatorial search it refers to constant space per processor, so that each processor stores only a constant number of words or tree nodes during execution (Pietracaprina et al., 2013). In approximation algorithms for bin packing it means a 1-bounded space algorithm in the sense of keeping at most one open bin at all times (Fujiwara et al., 26 Aug 2025). In restricted-RAM and read-only models it typically denotes computation with only $O(S)$ bits of workspace, often with $S$ as small as $\Theta(\lg N)$ or $O(\log n)$ (Darwish et al., 2015, De et al., 2012, Elmasry et al., 2015). In width-bounded dynamic programming it is closely related to frontier width $\omega=1$, which yields polylogarithmic-space traceback rather than full-table storage (Nye, 10 Dec 2025). Across these settings, the common objective is to preserve strong time or approximation guarantees while replacing explicit state retention by compressed encodings, recomputation, batching, lazy updates, or structural decompositions.

1. Terminology, models, and scope

The literature uses “1-bounded” and closely related terms in several technically distinct ways. A bounded space algorithm for bin packing keeps at most a constant number $B$ of open bins, and a 1-bounded space algorithm keeps at most one open bin (Fujiwara et al., 26 Aug 2025). In distributed-memory search, the relevant claim is that each processor stores only a constant number of words or nodes, even while exploring an $n$-node tree of height $h$ (Pietracaprina et al., 2013). In restricted-RAM work, the defining resource is a workspace of $O(S)$ bits with read-only random-access input and write-only output, typically under the regime $S \ge \lg N$ (Darwish et al., 2015). Read-only geometric algorithms similarly measure extra space in bits and aim for $S$0, $S$1, or $S$2 bits, depending on the problem (De et al., 2012, Elmasry et al., 2015). Parameterized and DP-DAG settings instead isolate structural parameters such as treedepth $S$3 or frontier width $S$4, and show that low-space behavior is possible when the active dependency interface is small (Chen et al., 2016, Nye, 10 Dec 2025).

A concise comparison of meanings is useful because many apparent disagreements are only model differences rather than substantive contradictions.

Setting	Meaning of bounded/1-bounded space	Representative guarantee
Parallel tree search	Constant space per processor	Backtrack search in $S$5 Las Vegas time w.h.p. (Pietracaprina et al., 2013)
Bin packing	At most one open bin	$S$6 for $S$7 (Fujiwara et al., 26 Aug 2025)
Restricted RAM	$S$8 bits workspace	Sorting and 2D convex hull in $S$9 (Darwish et al., 2015)
Read-only geometry	$\Theta(\lg N)$0 or $\Theta(\lg N)$1 bits	2D/3D LP in $\Theta(\lg N)$2 time and $\Theta(\lg N)$3 space (De et al., 2012)
Width-bounded DP	Frontier width $\Theta(\lg N)$4 controls memory	Traceback in $\Theta(\lg N)$5 cells (Nye, 10 Dec 2025)

This multiplicity of definitions is itself a central feature of the area. A common misconception is that “1-bounded” always means logarithmic-space computation in the classical complexity-theoretic sense. The cited work shows instead that the phrase ranges from one open combinatorial container, to constant local memory in parallel settings, to workspace bounds in bits, to constant active-frontier width.

2. Constant-space-per-processor parallel search

A foundational result for constant-space parallelism is the distributed-memory message-passing framework for backtrack search and branch-and-bound on an $\Theta(\lg N)$6-node tree of height $\Theta(\lg N)$7, under the assumption that a node can be accessed only through its father or its children (Pietracaprina et al., 2013). The model has $\Theta(\lg N)$8 processors $\Theta(\lg N)$9; each processor performs $O(\log n)$0 local work per step, sends or receives $O(\log n)$1 words per step, and stores one tree node per memory word. The searched tree is assumed binary for simplicity.

The backtrack-search algorithm is organized into epochs consisting of a traversal phase, a pairing phase, and a donation phase. Its crucial technical idea is a lazy implementation of subtree donation. Rather than storing a path of length up to $O(\log n)$2, a busy processor keeps only $O(\log n)$3 (root of its assigned subtree), $O(\log n)$4 (next node to touch), $O(\log n)$5, and two nodes $O(\log n)$6 that identify a tail and a possible right subtree to donate (Pietracaprina et al., 2013). Quick donation acts immediately when $O(\log n)$7 is defined; slow donation climbs the tail lazily and, if unfinished within one epoch, resumes later from a constant-size saved state. This removes the $O(\log n)$8-space path storage present in earlier approaches.

The resulting bounds are strong. For backtrack search, the deterministic algorithm runs in

$O(\log n)$9

and the Las Vegas randomized algorithm runs in

$\omega=1$0

with high probability, under $\omega=1$1 (Pietracaprina et al., 2013). The deterministic analysis partitions execution into full epochs and non-full epochs, with full epochs contributing $\omega=1$2, donating epochs before a node $\omega=1$3 is touched contributing $\omega=1$4, and preparing epochs contributing $\omega=1$5. The randomized pairing scheme uses constant-length traversal and pairing phases; a non-full epoch is donating or preparing with probability at least $\omega=1$6, which yields geometric control over waiting epochs.

The same constant-space design extends to branch-and-bound through a generalized selection problem. For a heap-ordered infinite tree $\omega=1$7, $\omega=1$8 is the subtree of nodes with cost at most $\omega=1$9, and $B$0 is defined as the largest cost such that $B$1 has at most $B$2 nodes and height at most $B$3 (Pietracaprina et al., 2013). Goodness testing of a node $B$4 is performed by exploring $B$5 and stopping when the subtree is fully visited, exceeds $B$6 nodes, or exceeds height $B$7. Random splitter selection uses reservoir sampling locally and combines samples in $B$8 rounds, still in constant space. The generalized selection algorithm determines $B$9 in

$n$0

time with high probability and constant space per processor, and the branch-and-bound algorithm requires

$n$1

parallel steps with high probability and constant space per processor; the abstract also states

$n$2

to emphasize the generalized-selection dependence (Pietracaprina et al., 2013).

The significance of these results is not only that parallel search can be made space-efficient, but that strong time bounds survive the elimination of per-processor stacks or frontier structures whose size depends on $n$3 or $n$4. A plausible implication is that constant local memory is compatible with nontrivial load balancing when the donation protocol itself is encoded as a fixed-size state machine.

3. Restricted-RAM and read-only workspace algorithms

In the restricted RAM model, the input is stored in a read-only random-access array, output is written to a write-only sequential stream, and the available workspace is $n$5 bits for a tunable parameter $n$6 (Darwish et al., 2015). The principal data structure in this regime is the adjustable navigation pile, a priority queue over a read-only array that supports $n$7 and $n$8 in $n$9 worst-case time and $h$0 in $h$1 worst-case time for any $h$2 (Darwish et al., 2015). It partitions the input into $h$3 buckets, builds a complete binary tree over the buckets, and stores compressed navigation information: a bit vector for nonempty ranges, relative bucket indices, active quantiles, and, in the augmented version, additional bits for nonmonotone candidate management. The bit budget satisfies

$h$4

which yields $h$5 bits overall (Darwish et al., 2015).

This compact priority queue gives optimal time-space tradeoffs for basic problems. Sorting $h$6 elements by repeated insert and extract takes

$h$7

and 2D convex hull computation achieves the same asymptotic bound with $h$8 bits of workspace (Darwish et al., 2015). The convex-hull algorithm uses an augmented navigation pile with $h$9, $O(S)$0, and $O(S)$1 structures, and proceeds in slabs: select the next $O(S)$2 candidate points by $O(S)$3-coordinate, build the augmented structure, compute their upper hull, prune by scanning points to the right, output hull points, and repeat (Darwish et al., 2015). The paper states that both sorting and convex hull are optimal because of a known lower bound for the space-time product of any branching program for finding unique elements.

A related but distinct line concerns read-only geometric optimization via prune-and-search (De et al., 2012). With the input in read-only memory, standard in-place pruning is impossible, so the algorithms rely on recomputation, read-only median selection, short pruning histories, and recursion paths of logarithmic depth. The reported bounds are: $O(S)$4 for unrestricted 2D convex hull,

$O(S)$5

for sorted-input 2D convex hull, and the same $O(S)$6-time, $O(S)$7-space bounds for 2D and 3D linear programming, where

$O(S)$8

(De et al., 2012). These results show that prune-and-search survives the loss of writable input.

Space-efficient plane sweep develops a more general read-only model with $O(S)$9 bits of workspace for $S \ge \lg N$0, and introduces three reusable techniques: stretching, batching, and multi-scanning (Elmasry et al., 2015). Representative bounds include closest pair in

$S \ge \lg N$1

general line-segment intersection enumeration in

$S \ge \lg N$2

counting axis-parallel segment intersections in

$S \ge \lg N$3

and unsorted Klee’s measure in

$S \ge \lg N$4

(Elmasry et al., 2015). The common pattern is to replace a full sweep-line status or global event queue by stripwise or cellwise local structures that fit in the available workspace.

Taken together, these works establish that severe workspace restrictions do not merely permit toy computations. They support optimal sorting, convex hulls, plane sweep, and low-dimensional linear programming, provided the algorithm is reorganized around compressed navigation, read-only median selection, slab decomposition, or explicit time-space tradeoffs.

4. Space-efficient graph traversal

Graph traversal offers a different manifestation of bounded space: the challenge is to avoid storing explicit stacks or queues of $S \ge \lg N$5 vertex identifiers. For breadth-depth search, the classical implementation uses $S \ge \lg N$6 time and $S \ge \lg N$7 bits in the word-RAM model, but both Jiang’s $S \ge \lg N$8 and Horowitz–Sahni’s $S \ge \lg N$9 can be implemented with substantially less space (Chakraborty et al., 2019). The central devices are 3-color arrays, delayed insertion for $S$00, delayed removal for $S$01, hierarchical blocking, reconstruction by replay, and compact adjacency-array pointer structures. The main theorem gives randomized $S$02 time using $S$03 bits with high probability, or deterministic $S$04 time using

$S$05

bits (Chakraborty et al., 2019). These space bounds are too small to store the classical stack explicitly, so the traversal state is represented only implicitly and reconstructed when needed.

Breadth-first search and depth-first search have parallel developments in the read-only input / write-only output model (Banerjee et al., 2016). A new dictionary maintains a subset $S$06 of a universe of size $S$07 using $S$08 bits, supports insert, delete, search, and findany in constant time, can enumerate all elements of the set in $S$09 time, and can be initialized in $S$10 time (Banerjee et al., 2016). Using this structure, BFS can be performed in $S$11 time using at most

$S$12

bits, by maintaining color classes corresponding to white, two grey levels, and black (Banerjee et al., 2016). The same paper further reduces BFS space to

$S$13

bits, first with polynomial time, then with $S$14 time via repeated scans, and finally with

$S$15

time using small queues and overflow flags (Banerjee et al., 2016). The $S$16 bound arises because vertices are stored in three color states rather than four.

For DFS, the paper first gives a linear-time implementation in $S$17 bits and then improves the bound to

$S$18

bits while preserving $S$19 time (Banerjee et al., 2016). The key lemma states that an auxiliary structure of size $S$20 bits can store a pointer into an arbitrary position within each vertex’s adjacency array, with $S$21-time updates (Banerjee et al., 2016). This yields an on-the-fly parent-pointer representation of the DFS tree and extends to chain decomposition, biconnectivity, 2-edge connectivity, bridges, and cut vertices within the same time and space bounds (Banerjee et al., 2016).

A central point emerging from these graph algorithms is that low space is achieved not by weakening traversal order, but by weakening the representation of the active frontier. Delayed insertion, delayed removal, replay, succinct color arrays, and adjacency-array pointers all preserve the combinatorial semantics while discarding explicit queue or stack materialization.

5. One-open-bin algorithms in bin packing

In one-dimensional bin packing, the notion of a 1-bounded space algorithm is completely different: it means that the algorithm keeps at most one open bin at all times (Fujiwara et al., 26 Aug 2025). The 2025 analysis of Zhu’s heuristic $S$22 places it at the intersection of two classes. A max-min algorithm first sorts items in non-increasing order by size and then repeatedly packs either the head or tail item of the remaining sequence into the current bin, without looking at interior items. A 1-bounded space algorithm maintains a single open bin (Fujiwara et al., 26 Aug 2025). Zhu’s $S$23 algorithm sorts the sequence, repeatedly packs as many largest remaining items as possible and then as many smallest remaining items as possible into the current single open bin, and opens a new bin only when the current one cannot accept the next tail item (Fujiwara et al., 26 Aug 2025).

The paper proves the universal bound

$S$24

hence

$S$25

for the asymptotic approximation ratio (Fujiwara et al., 26 Aug 2025). It also proves a lower bound for the entire class intersection: for any max-min 1-bounded space algorithm $S$26,

$S$27

and more precisely, for any even $S$28, there exists a sorted item sequence $S$29 such that

$S$30

(Fujiwara et al., 26 Aug 2025). The lower-bound construction uses item sizes

$S$31

with the property

$S$32

This frames the performance of the class intersection sharply: $S$33 The same paper also derives lower bounds for larger space classes of max-min algorithms,

$S$34

for max-min bounded space and

$S$35

for max-min unbounded space, showing that allowing more open bins improves possible guarantees (Fujiwara et al., 26 Aug 2025). It contrasts these results with pre-sorted online algorithms such as $S$36 and $S$37, noting that $S$38 has asymptotic ratio $S$39 but is not max-min 1-bounded, while the optimal asymptotic ratio for pre-sorted online bounded-space algorithms remains

$S$40

(Fujiwara et al., 26 Aug 2025).

The framework extends to $S$41-cardinality constrained bin packing via $S$42, which opens a new bin when the current bin already contains $S$43 items. The bound proved is

$S$44

hence

$S$45

where

$S$46

(Fujiwara et al., 26 Aug 2025). This branch of the literature shows that “1-bounded space” can encode a strong online-like restriction on feasible packing state rather than a bit-level memory bound.

6. Dynamic programming, treedepth, and width-bounded traceback

A major negative result for low-space algorithm design is that standard dynamic programming on decompositions is inherently space-expensive. For treedepth, treewidth, and pathwidth decompositions, a DPTM model captures one left-to-right pass over a valid decomposition encoding, with working space corresponding to the size of the DP tables (Chen et al., 2016). Using Myhill-Nerode families of boundaried graphs, the paper proves that for every $S$47, no DPTM can solve Dominating Set using

$S$48

space, no DPTM can solve 3-Coloring using

$S$49

space, and no DPTM can solve Vertex Cover using

$S$50

space, where $S$51 is the decomposition width or depth (Chen et al., 2016). This formalizes the intuition that bottom-up DP stores exponentially many boundary states.

The same work shows that treedepth is nevertheless useful for branching algorithms, which trade time for space. For 3-Coloring and Vertex Cover on treedepth $S$52, branching yields

$S$53

and

$S$54

respectively; for 3-Coloring the space can be reduced to essentially

$S$55

using a logarithmic-space depth-first traversal of the treedepth tree (Chen et al., 2016). For Dominating Set, the pure branching algorithm runs in

$S$56

time and

$S$57

space, while a hybrid branching-plus-DP algorithm runs in

$S$58

time and

$S$59

space (Chen et al., 2016). The conceptual conclusion is explicit: low-space tractability on treedepth comes from non-DP methods, not from better compression of standard tables.

A complementary positive result appears in the generalization of Hirschberg’s algorithm to width-bounded DP DAGs (Nye, 10 Dec 2025). A DP is modeled as deterministic time evolution over a topologically ordered DAG with frontier width

$S$60

bounded in-degree, a max-type semiring recurrence, and deterministic tie-breaking (Nye, 10 Dec 2025). The framework replaces backward DP by forward-only recomputation over a height-compressed recursion tree whose nodes expose small middle frontiers. The central theorem states that deterministic traceback requires

$S$61

cells over a fixed finite alphabet (Nye, 10 Dec 2025). For $S$62, traceback therefore uses $S$63 cells. The paper gives corollaries for one-dimensional recurrences, banded alignment, asymmetric alignment, and DP formulations on graphs of bounded pathwidth, and proves an $S$64 bits lower bound in forward single-pass models (Nye, 10 Dec 2025).

These two lines of work clarify an important misconception. Small structural width does not automatically imply low-space dynamic programming. For decomposition-based DP, exponential-space barriers remain. For width-bounded DP DAGs with random access and recomputation, however, traceback can be reduced to near the active-frontier cost. The difference is algorithmic architecture, not merely parameter choice.

7. Randomness, privacy, statistics, and quantum space

Space-bounded computation also reshapes derandomization and information-theoretic tasks. In the classical finite-state-machine model underlying Nisan’s generator, a randomized program uses space $S$65 and reads its random bits in blocks of size $S$66 (Kacham et al., 2023). The PRG called HashPRG or FastPRG generalizes Nisan’s construction by allowing $S$67-ary branching, yielding seed length

$S$68

bits, output length

$S$69

and $S$70 time to compute any $S$71-bit output block on a Word RAM with word size $S$72 (Kacham et al., 2023). Rewritten in space-vs-randomness form, a space-$S$73 algorithm making a single pass over a random string of length $S$74 can be fooled with seed length

$S$75

while still computing a block of $S$76 random bits in $S$77 time (Kacham et al., 2023). The same paper derives streaming applications with optimal or near-optimal space, including $S$78 estimation in

$S$79

bits and update time $S$80, together with a matching lower bound up to constants (Kacham et al., 2023).

Algorithmic statistics provides another bounded-space reinterpretation. Using space-bounded distinguishing complexity $S$81 and $S$82, the paper defines bounded-space randomness deficiency

$S$83

and optimality deficiency

$S$84

(Milovanov, 2017). It proves a bounded-space analogue of the classical connection between the two deficiencies, including

$S$85

for a suitable polynomial $S$86, and a converse-style theorem for acceptable families of hypotheses (Milovanov, 2017). A notable conceptual difference from the unbounded setting is that every string admits a good bounded-space explanation. This suggests that resource bounds weaken the distinction between stochastic and non-stochastic objects even while complicating exact optimization.

In privacy and adaptive data analysis, bounded space becomes an impossibility source rather than merely an implementation constraint. A two-stage model $S$87 is used, where $S$88 compresses the dataset or distribution into an $S$89-bit summary and $S$90 answers queries using only that summary (Dinur et al., 2023). Under standard cryptographic assumptions, the paper constructs a decoded-average problem for which the non-private space cost is

$S$91

while every efficient $S$92-CDP algorithm requires

$S$93

space in the formal corollary, yielding an exponential gap between private and non-private space requirements in the informal theorem (Dinur et al., 2023). The same work argues that adaptive data analysis lower bounds reflect a space bottleneck rather than a pure sample bottleneck, proving an $S$94-type space lower bound up to representation-length factors (Dinur et al., 2023).

Quantum bounded space exhibits analogous structural phenomena. For logspace quantum circuits preparing states $S$95 and $S$96, space-bounded quantum state testing for trace distance, Hilbert-Schmidt distance, entropy difference, and quantum Jensen–Shannon divergence all characterize the same bounded-space quantum class in the logspace regime (Gall et al., 2023). The technical engine is a space-efficient form of quantum singular value transformation on projected unitary encodings. The paper states that implementing QSVT for any bounded polynomial approximating a piecewise-smooth function incurs only a constant overhead in the required special-form space (Gall et al., 2023). This yields complete problems for unitary coRQL and BQL, and an algorithmic Holevo–Helstrom measurement. The broader implication is that even in quantum settings, bounded-space algorithm design depends on making the preprocessing and transformation layers themselves space-efficient, not only the final decision procedure.

Across these advanced directions, the role of space is not uniform. Sometimes it is a parameter to be traded against rescanning or seed length; sometimes it is the central hardness measure; and sometimes it collapses distinctions that are pronounced in time-bounded settings. What remains constant is that bounded-space computation forces algorithms to encode only the information that must cross an interface—between epochs, strips, frontiers, query stages, or circuit layers—and to reconstruct the rest on demand.