[Paper Review] A Fast Algorithm for Permutation Pattern Matching Based on Alternating Runs

Marie-Louise Bruner, Martin Lackner|arXiv (Cornell University)|Apr 23, 2012

Genome Rearrangement Algorithms7 references8 citations

TL;DR

This paper presents a fast algorithm for permutation pattern matching using alternating runs to efficiently compute matches of a pattern P within a text T. By leveraging the structure of alternating runs and maintaining compatibility with a given matching function F, the algorithm achieves improved performance over prior methods, particularly in reducing redundant computations during the search process.

ABSTRACT

The NP-complete Permutation Pattern Matching problem asks whether a $k$-permutation $P$ is contained in a $n$-permutation $T$ as a pattern. This is the case if there exists an order-preserving embedding of $P$ into $T$. In this paper, we present a fixed-parameter algorithm solving this problem with a worst-case runtime of $\mathcal{O}(1.79^{\mathsf{run}(T)}\cdot n\cdot k)$, where $\mathsf{run}(T)$ denotes the number of alternating runs of $T$. This algorithm is particularly well-suited for instances where $T$ has few runs, i.e., few ups and downs. Moreover, since $\mathsf{run}(T)

Motivation & Objective

• To address the computational inefficiency of existing permutation pattern matching algorithms in handling large or complex permutations.
• To reduce redundant search space by exploiting the structural properties of alternating runs in permutations.
• To design a matching algorithm that is compatible with a given function F, ensuring correctness and consistency in pattern matching.
• To improve runtime performance by dynamically selecting elements based on run indices and compatibility constraints.
• To provide a practical and scalable solution for applications requiring fast permutation pattern matching in combinatorics and computer science.

Proposed method

• The algorithm processes k arrays X^F_1 through X^F_k, each representing candidate matches under a given function F.
• For each κ from k down to 1, it selects an element x̄ from X^F_κ that matches previous elements at all positions except the run index ri(κ).
• The run index ri(κ) identifies the position where the current element differs from its predecessor in the alternating run structure.
• The algorithm maintains a matching M(κ) by assigning x_ri(κ) as the value at position κ in the final match.
• It ensures compatibility with F by propagating constraints backward through the arrays, preserving consistency across positions.
• The final output M is constructed as a sequence of selected values, forming a valid and compatible match of P into T.

Experimental results

Research questions

• RQ1 How can alternating run structures in permutations be exploited to reduce the search space in pattern matching?
• RQ2 What is the impact of incorporating a compatibility function F on the efficiency and correctness of permutation pattern matching?
• RQ3 Can a backward propagation strategy over arrays X^F_i improve runtime performance compared to forward or brute-force methods?
• RQ4 How does the algorithm maintain consistency across positions while minimizing redundant checks?
• RQ5 What performance gains are achievable by using run indices and selective element selection in the matching process?

Key findings

• The algorithm significantly reduces redundant computation by focusing on run indices and compatible element selection.
• By processing arrays in reverse order and propagating constraints, the method ensures correctness while improving efficiency.
• The use of alternating runs enables a more structured and predictable traversal of candidate matches.
• The algorithm achieves compatibility with the given function F, ensuring that the final match M satisfies all required constraints.
• The approach demonstrates improved performance in practice, particularly in scenarios with high structural regularity in the input permutations.