Maximum Feasible Substring under Pattern Supply

• MFSP is a combinatorial optimization problem that identifies the longest substring of a text meeting a pattern’s frequency (Parikh) constraints.
• It employs a linear-time two-pointer sliding window method which dynamically adjusts the substring to maintain feasibility.
• MFSP generalizes Abelian pattern matching, linking resource-budget interpretations with packing-style optimization in string analysis.

Maximum Feasible Substring under Pattern Supply (MFSP) is a combinatorial optimization problem arising in the context of frequency-based (Abelian/permutation/jumbled) pattern matching. Given a pattern $P$ and a text $T$ over a general alphabet $\Sigma$, MFSP seeks the longest substring of $T$ whose symbol counts are bounded, component-wise, by those of $P$. This exact resource-budget interpretation generalizes and connects standard Abelian pattern detection with packing-style primitives, and admits a linear-time solution via a two-pointer feasibility-maintenance algorithm (Shanto et al., 14 Jan 2026).

1. Formal Problem Definition

Let $\Sigma$ be an alphabet of size $\sigma$. Given a pattern $P \in \Sigma^m$ and a text $T \in \Sigma^n$, denote the Parikh vector of a string $S$ by

$T$0

for each $T$1. The pattern's Parikh vector $T$2 is interpreted as a supply or budget vector.

A substring $T$3 is feasible if

$T$4

or equivalently,

$T$5

The Maximum Feasible Substring under Pattern Supply (MFSP) asks to find

$T$6

The goal is to output the substring $T$7, which has the maximum length $T$8 under the component-wise Parikh budget constraint.

2. Linear-Time Two-Pointer Feasibility Algorithm

The core algorithmic insight is that feasibility under the Parikh budget constraint is monotone under left-shrinkage: when a window $T$9 becomes infeasible at some $\Sigma$0, increasing $\Sigma$1 can only reduce or restore feasibility. The solution maintains the following:

• $\Sigma$2 for all $\Sigma$3,
• $\Sigma$4 for all $\Sigma$5 (running counts for the current window),
• $\Sigma$6 = the number of $\Sigma$7 for which $\Sigma$8 (violation counter).

For each iteration, after extending the right end $\Sigma$9, the algorithm shrinks $T$0 while $T$1, ensuring each window $T$2 is maximal and feasible. The substring of maximum feasible length is retained.

Pseudocode outline:

$T$02

3. Proof Sketch: Correctness and Complexity

• Feasibility Invariant: After the inner while (viol > 0), $T$3 and so $T$4 is feasible; each counter $T$5 for all $T$6.
• Window Maximality: For each $T$7, shrinking $T$8 continues exactly while feasibility is violated, so $T$9 is a longest feasible suffix ending at $P$0.
• Global Optimality: For any optimal substring $P$1, when $P$2 the algorithm’s window will include a feasible window of length at least $P$3; the maximum seen is always retained.
• Time and Space Complexity: Each of pointers $P$4, $P$5 is advanced at most $P$6 times. Array initializations and per-symbol updates are $P$7. Initialization over $P$8 is $P$9; total runtime is $\Sigma$0. Space is $\Sigma$1 for $\Sigma$2, $\Sigma$3, and auxiliary counters.

4. Step-by-Step Example

Given $\Sigma$4 ($\Sigma$5, $\Sigma$6) and $\Sigma$7 ($\Sigma$8):

$\Sigma$9	Added char	$\sigma$0 change	$\sigma$1	Window $\sigma$2	Remarks / $\sigma$3
0	'a'	$\sigma$4	0	$\sigma$5	Set $\sigma$6
1	'b'	$\sigma$7	0	$\sigma$8	Set $\sigma$9
2	'a'	$P \in \Sigma^m$0	0	$P \in \Sigma^m$1	Set $P \in \Sigma^m$2
3	'a'	$P \in \Sigma^m$3	1	shrink $P \in \Sigma^m$4: $P \in \Sigma^m$5, $P \in \Sigma^m$6, resolve violation	No update (tie)
4	'c'	$P \in \Sigma^m$7	1	shrink $P \in \Sigma^m$8: $P \in \Sigma^m$9, $T \in \Sigma^n$0, resolve violation	No update
5	'b'	$T \in \Sigma^n$1	0	$T \in \Sigma^n$2	Set $T \in \Sigma^n$3

The returned substring is $T \in \Sigma^n$4 of length $T \in \Sigma^n$5, conforming to the Parikh budget $T \in \Sigma^n$6.

5. Specializations and Connections

• Single-Symbol Cases: For $T \in \Sigma^n$7 with a single symbol $T \in \Sigma^n$8 at frequency $T \in \Sigma^n$9, MFSP reduces to the classic search for the longest run of $S$0 in $S$1.
• Alphabet Reduction: If $S$2 is large but $S$3 is small, the alphabet can be compressed to a smaller effective size $S$4 prior to algorithm execution.
• Permutation Matching and Packing: MFSP generalizes permutation matching, which asks whether some substring's Parikh vector exactly matches $S$5; this variant is handled by maintaining a difference vector and can also be solved in $S$6 time within this framework.
• Non-overlapping Occurrences: After enumerating all length-$S$7 matches, maximizing the count of disjoint occurrences reduces to the equal-length interval packing problem, solved by left-to-right greedy selection in $S$8 time.

6. Generalizations and Further Directions

• Approximate and Weighted Variants: MFSP admits relaxation to allow limited violation (e.g., $S$9), or extension to weighted settings where each symbol is associated with a cost or value, yielding knapsack-like, resource-constrained substring optimization problems.
• Relation to Sliding-Window and Packing Paradigms: MFSP demonstrates that frequency-based string matching admits precise resource-budget interpretations, connecting classic sliding-window substring search with packing-style optimization. This suggests a broader applicability in text algorithms and resource allocation frameworks (Shanto et al., 14 Jan 2026).

7. Summary

MFSP formalizes and solves, in optimal $T$00 time and $T$01 space, the problem of finding the longest substring under Parikh-component supply constraints. This sliding-window, two-pointer algorithm extends permutation matching, supports concise maximal-resource interpretations, and links string algorithms to combinatorial packing primitives (Shanto et al., 14 Jan 2026).