Longest Run Subsequence Problem

• The Longest Run Subsequence problem is defined as finding a maximum-length subsequence where each symbol appears in a single contiguous block.
• It is NP-hard yet fixed-parameter tractable under parameters like alphabet size and number of runs, with strong kernelization lower bounds.
• Algorithmic approaches range from exact ILP formulations and greedy decoders to randomized FPT strategies and metaheuristics, with practical use in genome assembly.

The Longest Run Subsequence (LRS) problem asks, for a string $s \in \Sigma^*$, for a maximum-length subsequence $t$ such that each symbol $a \in \Sigma$ appears in $t$ in at most one run, equivalently, all occurrences of $a$ in $t$ form a single contiguous block in $t$. Introduced in the context of the scaffolding phase of genome assembly, the problem lies at the intersection of subsequence optimization, run-structured combinatorics, and parameterized complexity. Its known theory combines NP-hardness, fixed-parameter tractability under several parameterizations, kernelization lower bounds, approximation and inapproximability results, and both exact and metaheuristic solution approaches (Dondi et al., 2020).

1. Formal definition and equivalent views

Let $\Sigma$ be a finite alphabet and let $s \in \Sigma^*$ be a string of length $n$, written $t$0. A run of $t$1 is any interval $t$2, $t$3, such that $t$4, and $t$5 and $t$6. An $t$7-run is a run whose symbol is $t$8 (Dondi et al., 2020).

A subsequence $t$9 of $a \in \Sigma$0 is specified by strictly increasing indices $a \in \Sigma$1 with $a \in \Sigma$2. Runs in the subsequence are defined with respect to adjacency within $a \in \Sigma$3: a run in $a \in \Sigma$4 is a maximal block of equal symbols appearing consecutively in $a \in \Sigma$5, not necessarily consecutive in $a \in \Sigma$6. The LRS optimization problem asks for a maximum-length subsequence $a \in \Sigma$7 of $a \in \Sigma$8 such that each symbol $a \in \Sigma$9 appears in $t$0 in at most one run. The decision version, parameterized by a target length $t$1, asks whether there exists a subsequence $t$2 of length at least $t$3 such that, for every $t$4, the occurrences of $t$5 in $t$6 are contained in a single run.

An equivalent characterization uses run-length encoding. Any LRS solution $t$7 decomposes into at most one run per symbol, and the sequence of run symbols is repetition-free. Thus $t$8's run-length encoding uses each symbol at most once. This formulation makes clear that a run picked in the solution need not be maximal in the input string, and not every symbol must appear. For example, for $t$9, an optimal LRS is $a$0, which selects non-maximal runs for $a$1 and $a$2 and omits $a$3 (Dondi et al., 2020).

A later formulation compresses the input into its maximal constant-letter substrings $a$4, ordered by occurrence in $a$5, where each run $a$6 has letter $a$7 and length $a$8. Under this view, if an optimal LRS subsequence includes any letter from a given run in $a$9, it includes all letters of that run. Hence a valid LRS solution can be expressed as a subset $t$0 subject to the condition that if $t$1 with $t$2 and $t$3, then there is no $t$4 with $t$5 and $t$6. The objective becomes

$t$7

This run-based simplification is the basis for later ILP and metaheuristic methods (Blum et al., 19 Aug 2025).

2. Genome-assembly motivation and relation to adjacent problems

LRS was introduced recently in the context of the scaffolding phase of genome assembly. In scaffolding, bins in one assembly are matched to contigs in another. Errors and structural variations cause a contig to appear scattered across bins. LRS seeks a longest subsequence of contig matches in which every contig appears in at most one contiguous block, filtering out inconsistent mappings and suggesting a plausible partition into contigs. This directly captures the expectation that, in a correctly scaffolded ordering, each contig should appear as a single block (Dondi et al., 2020).

The problem is distinct from classical order-constrained subsequence problems. Longest Increasing Subsequence imposes an order constraint on subsequences, whereas LRS imposes a run-contiguity constraint per symbol. It is also distinct from standard run-length encoded string problems, where runs are computational units for problems such as LCS on run-length encoded inputs. LRS operates on a single string and restricts the subsequence to at most one run per symbol, which makes selection combinatorial and NP-hard (Dondi et al., 2020).

The restriction is also different from problems based on repeated motifs. The Longest Subsequence-Repeated Subsequence problem allows repeated units $t$8 that are arbitrary subsequences and does not restrict a letter to appear in only one block globally, whereas LRS requires at most one run per symbol. This difference is structurally important: LSRS is reported as polynomial-time solvable in $t$9 for the unconstrained version, while LRS is NP-hard (Lafond et al., 2023). This suggests that the global uniqueness-of-run constraint, rather than mere block structure, is the principal source of hardness.

3. Complexity landscape

The basic complexity status is established by two strands of results. First, LRS is NP-hard, as shown by Schrinner et al. in WABI 2020. Second, the problem is fixed-parameter tractable when parameterized by the alphabet size $t$0, via an algorithm that uses exponential space, yielding time $t$1 for some computable $t$2 (Dondi et al., 2020).

Dondi and Sikora strengthened the parameterized picture by proving fixed-parameter tractability with respect to a smaller parameter, namely the number of runs in the solution. Let $t$3 be the number of runs in a chosen subsequence. Then LRS is FPT parameterized by $t$4. They also established kernelization lower bounds: LRS admits no polynomial kernel when parameterized by $t$5 unless NP $t$6 coNP/poly, and, since $t$7, the same lower bound follows for parameter $t$8 (Dondi et al., 2020).

At the same time, there is a simple positive kernelization result for the solution-length parameter $t$9. If $\Sigma$0, one occurrence per symbol yields a solution of length $\Sigma$1. If some symbol occurs at least $\Sigma$2 times, then a run of that symbol of length $\Sigma$3 is a solution. Otherwise $\Sigma$4 and each symbol occurs fewer than $\Sigma$5 times, so the total instance size is at most $\Sigma$6. Thus LRS admits a polynomial kernel of size $\Sigma$7 when parameterized by $\Sigma$8 (Dondi et al., 2020).

The approximation landscape is similarly mixed. A simple $\Sigma$9-approximation is obtained by comparing two candidates: the solution taking one occurrence per symbol, of length $s \in \Sigma^*$0, and the longest $s \in \Sigma^*$1-run, of length equal to the maximum symbol frequency. The better of these is a $s \in \Sigma^*$2-approximation, which yields a $s \in \Sigma^*$3 factor in the worst case. Against this upper bound stands a strong negative result: even when each symbol appears at most twice in the input string, LRS remains APX-hard, ruling out a PTAS unless $s \in \Sigma^*$4 (Dondi et al., 2020).

A later paper places these results into a broader algorithmic picture, noting additionally that Asahiro et al. provided approximation algorithms under $s \in \Sigma^*$5-occurrence constraints, specifically $s \in \Sigma^*$6, and $s \in \Sigma^*$7 when $s \in \Sigma^*$8 (Blum et al., 19 Aug 2025).

4. Randomized FPT algorithm parameterized by the number of runs

The FPT algorithm for parameter $s \in \Sigma^*$9 is based on a reduction to $n$0-Multilinear Detection (k-MLD) through an arithmetic-circuit encoding. The theorem states: there exists a randomized algorithm that, given $n$1 and integers $n$2, decides if there exists a run subsequence of length $n$3 with exactly $n$4 runs in time

$n$5

and polynomial space. By iterating over $n$6, this solves the version with target length at least $n$7 (Dondi et al., 2020).

The construction introduces one variable $n$8 per alphabet symbol $n$9, and dynamic-programming circuit nodes $t$00 encoding the statement that there exists an LRS subsequence within $t$01 of length $t$02 with exactly $t$03 runs. The root is $t$04. The recurrence is

$t$05

The base cases are

$t$06

The recurrence has a direct combinatorial interpretation. The term $t$07 skips position $t$08. The summation adds a new terminal run on symbol $t$09, of length $t$10, after a feasible prefix with $t$11 runs and length $t$12. Multiplication by $t$13 marks the use of symbol $t$14; multilinearity then enforces that each symbol is used in at most one run globally.

Correctness is captured by the key lemma: there exists a run subsequence of $t$15 of length $t$16 consisting of $t$17 runs over distinct symbols $t$18 if and only if the circuit contains a degree-$t$19 multilinear monomial $t$20 in $t$21, and hence in $t$22 for $t$23, $t$24, $t$25. The algorithm then invokes the Koutis–Williams randomized algorithm for k-MLD, which solves k-MLD on a circuit $t$26 in randomized time $t$27 and space $t$28. Since the circuit size is $t$29, iterating over all $t$30 yields total time $t$31 and polynomial space (Dondi et al., 2020).

This algorithm is algebraic rather than combinatorial in the usual DP sense. A plausible implication is that its main significance is structural: it shows that the decisive combinatorial bottleneck is the number of symbol-blocks in the solution, not the input alphabet alone.

5. Kernelization lower bounds and hard restricted variants

The kernelization lower bounds are obtained by OR-cross-composition from unparameterized LRS to its parameterized variants. For parameter $t$32, given $t$33 instances $t$34, equalized by length $t$35, alphabet size $t$36, and target $t$37, all alphabets are relabeled to $t$38, and a new instance is built over

$t$39

with string

$t$40

and target

$t$41

The separator blocks force any feasible solution to use exactly one run on $t$42 and one run on $t$43, and to be contained within exactly one block $t$44. Hence $t$45 has an LRS of length at least $t$46 if and only if at least one original instance does. Since $t$47, the cross-composition implies that LRS admits no polynomial kernel parameterized by $t$48 unless NP $t$49 coNP/poly (Dondi et al., 2020).

The corollary for parameter $t$50 is immediate from $t$51: LRS has no polynomial kernel parameterized by the number of runs unless NP $t$52 coNP/poly. These results sharply separate fixed-parameter tractability from kernelizability for the most natural structural parameters.

The APX-hardness result shows that the difficulty persists under a severe frequency restriction. When each symbol appears at most twice in the input string, LRS remains APX-hard via an L-reduction from Maximum Independent Set on cubic graphs. The construction uses vertex symbols $t$53, edge-related symbols $t$54, $t$55, separators $t$56, and separator triplets $t$57. Canonical subsequences can be enforced so that each vertex gadget contributes either $t$58 or an $t$59-heavy block, and edge gadgets enforce consistency: adjacent vertices cannot both contribute $t$60. The reduction has constants $t$61 and $t$62, and therefore LRS with at most two occurrences per symbol is APX-hard and admits no PTAS unless $t$63 (Dondi et al., 2020).

A later paper uses this restricted-case hardness as part of a practical algorithmic motivation: exact methods such as ILP and DP may solve only modest-size instances, making heuristics and metaheuristics natural for scalability (Blum et al., 19 Aug 2025).

6. Exact formulations, heuristic methods, and empirical performance

A compact integer linear programming model, reported from Schrinner et al., uses one binary variable $t$64 for each run $t$65: $t$66 The objective is

$t$67

and validity is enforced by constraints stating that if two selected runs of the same letter are chosen, then no selected run of a different letter may lie between them: $t$68 If $t$69, the right-hand side is $t$70, so all intervening foreign-letter runs are forbidden; if at least one endpoint is unselected, the constraint becomes nonbinding. This model enforces that, for each letter $t$71, the selected run indices carrying $t$72 form a contiguous block (Blum et al., 19 Aug 2025).

The same paper presents a Biased Random Key Genetic Algorithm (BRKGA) and a Max–Min Ant System (MMAS) for LRS. In the BRKGA, an individual is a vector $t$73, one key per run. Decoding sorts runs by non-increasing key and greedily adds them if validity is preserved. The validity check is implemented with per-letter lower and upper bounds, $t$74 and $t$75, initialized to $t$76. For a candidate run $t$77 with letter $t$78, insertion is allowed only if, for every $t$79, the three conditions

$t$80

$t$81

$t$82

all hold. If accepted, $t$83 and $t$84 are updated. The fitness is

$t$85

Evaluation cost is $t$86, and measured decoding times are generally well below $t$87 ms, with only a few evaluations for $t$88 slightly exceeding $t$89 ms (Blum et al., 19 Aug 2025).

The reported BRKGA parameters are population size $t$90, elite fraction $t$91, mutant fraction $t$92, and crossover probability $t$93. The MMAS comparator uses one pheromone per run, learning rate $t$94, $t$95 solution constructions per iteration, and determinism rate $t$96. CPLEX 22.1 is used on the ILP model in sequential mode, under the same time limit $t$97 CPU seconds per instance (Blum et al., 19 Aug 2025).

The experiments use $t$98 uniformly random instances: for each $t$99 and $a \in \Sigma$00, $a \in \Sigma$01 instances are generated. Across all $a \in \Sigma$02 instances, BRKGA obtains the best solution quality on average and outperforms MMAS and CPLEX with statistical significance. For $a \in \Sigma$03, BRKGA and MMAS reach the same average best values, but MMAS requires notably more time. As $a \in \Sigma$04 increases, MMAS degrades markedly relative to BRKGA. For the shortest strings, $a \in \Sigma$05 with $a \in \Sigma$06, CPLEX produced slightly better solutions within the time limit than BRKGA. CPLEX solved only the smallest or easiest cases to near-optimality, and its optimality gaps grew rapidly with $a \in \Sigma$07 and $a \in \Sigma$08 (Blum et al., 19 Aug 2025).

These results do not alter the formal complexity picture, but they clarify the present methodological split. Exact formulations remain useful on small instances, while large-instance practice currently relies on run-compressed representations and extremely fast validity-preserving decoding.

7. Open directions

The open problems explicitly highlighted include improving approximation algorithms beyond the trivial $a \in \Sigma$09 bound and closing the gap with APX-hardness; evaluating the practical competitiveness of the randomized multilinear-detection FPT algorithm against ILP formulations and heuristics; and further exploration of parameterizations and structural restrictions that might yield efficient exact or approximation algorithms (Dondi et al., 2020).

The later BRKGA study isolates a concrete practical limitation: performance on short strings with large $a \in \Sigma$10, where CPLEX can still be competitive, and the absence of domain-informed heuristic information for improving the decoder beyond pure greedy feasibility. This suggests that the empirical frontier is no longer only about raw search power, but also about the quality of structure-aware decoding and hybrid exact-heuristic strategies (Blum et al., 19 Aug 2025).

Taken together, the current state of LRS is unusually well stratified. The formal side provides precise separations between NP-hardness, FPT solvability, kernel lower bounds, and APX-hardness. The algorithmic side provides both algebraic FPT machinery and run-based practical solvers. The remaining questions concern how closely these two perspectives can be brought together without weakening either exactness or scalability.