Common-suffix and common-prefix lengths per position, a running maximum, then an alphabetical tie-break. **Two match lengths per position.** A prefix match of length k ending at position e means text[e-k:e] equals the last k characters of prefixString, so text[:e] and prefixString share a common suffix of length k. If the longest such k at e is K, every shorter length also matches there. So one number per position is enough: ends[e], the longest common suffix of text[:e] and prefixString. Symmetrically, starts[b] is the longest common prefix of text[b:] and suffixString, and every shorter suffix match starting at b also works. **Best total.** Keep the prefix match before the suffix match: a match ending at e and a match starting at b combine when e <= b, and the substring is text[e-k : b+m]. For each b the best prefix side is the largest ends[e] with e <= b, a running maximum, so the best total is max over b of best_end[b] + starts[b]. That is linear once the two arrays exist. **Computing the arrays.** Directly, or with a longest-common-substring style DP table, costs O(n * (|P| + |S|)); one report says the solution is dynamic programming. A linear-time matcher gets them in O(n + |P| + |S|): the reference runs the Z-function on suffixString + separator + text for starts, and on the reversed strings for ends (reversing turns a common suffix into a common prefix). Another report says to use KMP; its prefix function belongs to the same family and can produce the same lengths. **Ties.** At the best total, a split point b can only reach it with k = best_end[b] and m = starts[b], because neither can be larger. What still varies is where the prefix match starts: every e <= b whose ends[e] equals k gives a candidate text[e-k : b+m]. Compare the candidates as strings and keep the alphabetically lowest, which is the tie rule in one report's prompt. Comparing candidates is the only part that is not linear.