The Ruzzo–Tompa algorithm or the RT algorithm^[1] is a linear-time algorithm for finding all non-overlapping, contiguous, maximal scoring subsequences in a sequence of real numbers.^[2] The Ruzzo–Tompa algorithm was proposed by Walter L. Ruzzo and Martin Tompa.^[3] This algorithm is an improvement over previously known quadratic time algorithms.^[1] The maximum scoring subsequence from the set produced by the algorithm is also a solution to the maximum subarray problem.

The Ruzzo–Tompa algorithm has applications in bioinformatics,^[4] web scraping,^[5] and information retrieval.^[6]

Applications

Problem definition

The problem of finding all maximal subsequences is defined as follows: Given a list of real numbered scores ${\displaystyle x_{1},x_{2},\ldots ,x_{n}}$, find the list of contiguous subsequences that gives the greatest total score, where the score of each subsequence ${\displaystyle S_{i,j}=\sum _{i\leq k\leq j}x_{k}}$. The subsequences must be disjoint (non-overlapping) and have a positive score.^[9]

Other algorithms

There are several approaches to solving the all maximal scoring subsequences problem. A natural approach is to use existing, linear time algorithms to find the maximum subsequence (see maximum subarray problem) and then recursively find the maximal subsequences to the left and right of the maximum subsequence. The analysis of this algorithm is similar to that of Quicksort: The maximum subsequence could be small in comparison to the rest of sequence, leading to a running time of ${\displaystyle O(n^{2})}$ in the worst case.

Algorithm

This animation shows the Ruzzo–Tompa algorithm running with an input sequence of 11 integers each represented by a line segment in the graph. Segments with bold lines represent maximal segments found so far. The animation shows the state of ${\displaystyle I,R}$ and ${\displaystyle L}$ at each step. Below that it shows the current state the algorithm which correspond to steps 1–4 in the Algorithm section of this page. The red highlight shows the algorithm finding a value for ${\displaystyle j}$ in steps 1 and 3. If the value of ${\displaystyle j}$ satisfies the inequalities in those steps the highlight turns green. At the end of the animation, the maximal subsequences will be bolded and displayed in ${\displaystyle I}$.^[1]

The standard implementation of the Ruzzo–Tompa algorithm runs in ${\displaystyle O(n)}$ time and uses O(n) space, where n is the length of the list of scores. The algorithm uses dynamic programming to progressively build the final solution by incrementally solving progressively larger subsets of the problem. The description of the algorithm provided by Ruzzo and Tompa is as follows:

Read the scores left to right and maintain the cumulative sum of the scores read. Maintain an ordered list ${\displaystyle I_{1},I_{2},\ldots ,I_{j}}$ of disjoint subsequences. For each subsequence ${\displaystyle I_{j}}$, record the cumulative total ${\displaystyle L_{j}}$ of all scores up to but not including the leftmost score of ${\displaystyle I_{j}}$, and the total ${\displaystyle R_{j}}$ up to and including the rightmost score of ${\displaystyle I_{j}}$.

The lists are initially empty. Scores are read from left to right and are processed as follows. Nonpositive scores require no special processing, so the next score is read. A positive score is incorporated into a new sub-sequence ${\displaystyle I_{k}}$ of length one that is then integrated into the list by the following process:

1. The list ${\displaystyle I}$ is searched from right to left for the maximum value of ${\displaystyle j}$ satisfying ${\displaystyle L_{j}<L_{k}}$
2. If there is no such ${\displaystyle j}$, then add ${\displaystyle I_{k}}$ to the end of the list.
3. If there is such a ${\displaystyle j}$, and ${\displaystyle R_{j}\geq R_{k}}$, then add ${\displaystyle I_{k}}$ to the end of the list.
4. Otherwise (i.e., there is such a j, but ${\displaystyle R_{j}<R_{k}}$), extend the subsequence ${\displaystyle I_{k}}$ to the left to encompass everything up to and including the leftmost score in ${\displaystyle I_{j}}$. Delete subsequences ${\displaystyle I_{j},I_{j}+1,\ldots ,I_{k}-1}$ from the list, and append ${\displaystyle I_{k}}$ to the end of the list. Reconsider the newly extended subsequence ${\displaystyle I_{k}}$ (now renumbered ${\displaystyle I_{j}}$) as in step 1.

Once the end of the input is reached, all subsequences remaining on the list ${\displaystyle I}$ are maximal.^[2]

The following Python code implements the Ruzzo–Tompa algorithm:

def ruzzo_tompa(scores):
	"""Ruzzo–Tompa algorithm."""
	k = 0
	total = 0
	# Allocating arrays of size n
	I, L, R, Lidx = [[0] * len(scores) for _ in range(4)]
	for i, s in enumerate(scores):
    	total += s
    	if s > 0:
        	# store I[k] by (start,end) indices of scores
        	I[k] = (i, i + 1)
        	Lidx[k] = i
        	L[k] = total - s
        	R[k] = total
        	while True:
            	maxj = None
            	for j in range(k - 1, -1, -1):
                	if L[j] < L[k]:
                    	maxj = j
                    	break
            	if maxj is not None and R[maxj] < R[k]:
                	I[maxj] = (Lidx[maxj], i + 1)
                	R[maxj] = total
                	k = maxj
            	else:
                	k += 1
                	break
	# Getting maximal subsequences using stored indices
	return [scores[I[l][0] : I[l][1]] for l in range(k)]

See also

• Maximum subarray problem
• Quicksort

References

Further reading

• Ali, Syed Arslan; Raza, Basit; Malik, Ahmad Kamran; Shahid, Ahmad Raza; Faheem, Muhammad; Alquhayz, Hani; Kumar, Yogan Jaya (2020). "An Optimally Configured and Improved Deep Belief Network (OCI-DBN) Approach for Heart Disease Prediction Based on Ruzzo–Tompa and Stacked Genetic Algorithm". IEEE Access. Institute of Electrical and Electronics Engineers (IEEE). 8: 65947–65958. doi:10.1109/access.2020.2985646. ISSN 2169-3536. S2CID 215817246.